![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mull3.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 mull3.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 00000d38 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _mull3
6: 6 00000000 _mull3:
7: 7 00024C8C 0000 .word L215
8: 8 00024C8E # #include "fpp_defs.h"
9: 9 00024C8E #
10: 10 00024C8E #
11: 11 00024C8E # /***************************************************************************
12: 12 00024C8E # *
13: 13 00024C8E # * MULL3 -MULTIPLY INTEGER 3 INSTRUCTION TEST
14: 14 00024C8E # *
15: 15 00024C8E # *****************************************************************************/
16: 16 00024C8E # mull3()
17: 17 00024C8E # {
18: 18 00024C8E 11 4f jbr L217
19: 19 00024C90 L218:
20: 20 00024C90 # asm(".globl _mull3_t");
21: 21 00024C90 .globl _mull3_t
22: 22 00024C90 # asm("_mull3_t:"); /* entry address */
23: 23 00024C90 _mull3_t:
24: 24 00024C90 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
25: 25 00024C90 1d effffffff6 01 cmpl _cycle,$1
26: 26 00024C97 21 15 jneq L219
27: 27 00024C99 5d efffffffed tstl _prt_hdrs
28: 28 00024C9F 31 0d jeql L219
29: 29 00024CA1 # {
30: 30 00024CA1 # writes(" MULL3");
31: 31 00024CA1 .data 1
32: 32 00000d38 * L221:
33: 33 00000d38 * 204D554C4C3300 .ascii " MULL3\0"
34: 34 00000d3f * .text
35: 35 00024CA1 dd 8f00000d38 pushl $L221
36: 36 00024CA7 fe 08 efffffffde callf $8,_writes
37: 37 00024CAE # }
38: 38 00024CAE # mull3_1(); /* register data / SGL acc. */
39: 39 00024CAE L219:
40: 40 00024CAE fe 04 ef0000002d callf $4,_mull3_1
41: 41 00024CB5 # mull3_2(); /* memory data / DBL acc. */
42: 42 00024CB5 fe 04 ef000001d0 callf $4,_mull3_2
43: 43 00024CBC # mull3_3(); /* register corruption test */
44: 44 00024CBC fe 04 ef000003d3 callf $4,_mull3_3
45: 45 00024CC3 # mull3_4(); /* PSL corruption test */
46: 46 00024CC3 fe 04 ef0000055c callf $4,_mull3_4
47: 47 00024CCA # mull3_5(); /* pipelined entry test */
48: 48 00024CCA fe 04 ef000006f9 callf $4,_mull3_5
49: 49 00024CD1 # mull3_6(); /* pipelined exit test */
50: 50 00024CD1 fe 04 ef000008be callf $4,_mull3_6
51: 51 00024CD8 # asm("jmp *return"); /* return to the test monitor */
52: 52 00024CD8 71 ffffffffae jmp *return
53: 53 00024CDE # }
54: 54 00024CDE 40 ret#2
55: 55 00024CDF .set L215,0x0
56: 56 00024CDF L217:
57: 57 00024CDF 11 af jbr L218
58: 58 00024CE1 .data
59: 59 00000d38 * .text
60: 60 00024CE1 00 .align 1
61: 61 00024CE2 .globl _mull3_1
62: 62 00024CE2 _mull3_1:
63: 63 00024CE2 0000 .word L228
64: 64 00024CE4 #
65: 65 00024CE4 #
66: 66 00024CE4 #
67: 67 00024CE4 # /************************************************************************
68: 68 00024CE4 # *
69: 69 00024CE4 # * SUBTEST 1 - register addressing / single precsion accumulator
70: 70 00024CE4 # *
71: 71 00024CE4 # ************************************************************************/
72: 72 00024CE4 # mull3_1()
73: 73 00024CE4 # {
74: 74 00024CE4 13 01a2 jbr L230
75: 75 00024CE7 L231:
76: 76 00024CE7 # force_loop = FALSE;
77: 77 00024CE7 4d efffffff9f clrl _force_loop
78: 78 00024CED # subtest = 1;
79: 79 00024CED 0d 01 efffffff98 movl $1,_subtest
80: 80 00024CF4 # for( index = 0; index < max_mull_1_index; index++ ) {
81: 81 00024CF4 4d efffffff92 clrl _index
82: 82 00024CFA L234:
83: 83 00024CFA 1d efffffff8c efffffff87 cmpl _index,_max_mull_1_index
84: 84 00024D05 91 03 13 017e jgeq L233
85: 85 00024D0A # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
86: 86 00024D0A 5c 0c efffffff7b 50 mull3 $12,_index,r0
87: 87 00024D12 0d e000000000 efffffff6f movl _mull_1_data(r0),_sgl_value_1
88: 88 00024D1D # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
89: 89 00024D1D 5c 0c efffffff68 50 mull3 $12,_index,r0
90: 90 00024D25 0d e000000004 efffffff5c movl _mull_1_data+4(r0),_sgl_value_2
91: 91 00024D30 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */
92: 92 00024D30 5c 0c efffffff55 50 mull3 $12,_index,r0
93: 93 00024D38 0d e000000008 efffffff49 movl _mull_1_data+8(r0),_sgl_value_4
94: 94 00024D43 # sgl_ld_acc = 0x12345678; /* set acc data pattern */
95: 95 00024D43 0d 8f12345678 efffffff3e movl $305419896,_sgl_ld_acc
96: 96 00024D4E # sgl_expected = sgl_ld_acc; /* final Acc expected */
97: 97 00024D4E 0d efffffff38 efffffff33 movl _sgl_ld_acc,_sgl_expected
98: 98 00024D59 # /*
99: 99 00024D59 # * If LOOP ON ERROR is set, this is the loop for this subtest.
100: 100 00024D59 # */
101: 101 00024D59 # asm("_mull3_1_lp1:");
102: 102 00024D59 _mull3_1_lp1:
103: 103 00024D59 # asm("movl _sgl_value_1,r3"); /* move the 1st data to r3 */
104: 104 00024D59 0d efffffff2d 53 movl _sgl_value_1,r3
105: 105 00024D60 # asm("movl _sgl_value_2,r4"); /* move the 2nd data to r4 */
106: 106 00024D60 0d efffffff26 54 movl _sgl_value_2,r4
107: 107 00024D67 # asm("ldf _sgl_ld_acc"); /* load the acc */
108: 108 00024D67 06 efffffff1f ldf _sgl_ld_acc
109: 109 00024D6D # asm("mull3 r3,r4,r5"); /* do the multiply */
110: 110 00024D6D 5c 53 54 55 mull3 r3,r4,r5
111: 111 00024D71 # asm("nop");
112: 112 00024D71 10 nop
113: 113 00024D72 # asm("stf _sgl_st_acc"); /* save the acc */
114: 114 00024D72 26 efffffff14 stf _sgl_st_acc
115: 115 00024D78 # if( force_loop )
116: 116 00024D78 5d efffffff0e tstl _force_loop
117: 117 00024D7E 31 02 jeql L235
118: 118 00024D80 # asm("brb _mull3_1_lp1");;
119: 119 00024D80 11 d7 brb _mull3_1_lp1
120: 120 00024D82 L235:
121: 121 00024D82 # asm("movl r5,_sgl_value_3");
122: 122 00024D82 0d 55 efffffff03 movl r5,_sgl_value_3
123: 123 00024D89 # if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */
124: 124 00024D89 1d effffffefd effffffef8 cmpl _sgl_expected,_sgl_st_acc
125: 125 00024D94 21 03 13 0098 jeql L236
126: 126 00024D99 # errcnt++; /* bump the error count */
127: 127 00024D99 6d effffffeed incl _errcnt
128: 128 00024D9F # if ( prt_error ) {
129: 129 00024D9F 5d effffffee7 tstl _prt_error
130: 130 00024DA5 31 64 jeql L237
131: 131 00024DA7 # print_mull3_error("(Reg. Data) -THE ACC WAS MODIFIED");
132: 132 00024DA7 .data 1
133: 133 00000d3f * L239:
134: 134 00000d3f * 285265672E204461746129202 .ascii "(Reg. Data) -THE ACC WAS MODIFIED\0"
135: D544845204143432057415320
136: 4D4F44494649454400
137: 135 00000d61 * .text
138: 136 00024DA7 dd 8f00000d3f pushl $L239
139: 137 00024DAD fe 08 ef000009ae callf $8,_print_mull3_error
140: 138 00024DB4 # writes("initial Acc = ");
141: 139 00024DB4 .data 1
142: 140 00000d61 * L240:
143: 141 00000d61 * 696E697469616C20416363203 .ascii "initial Acc = \0"
144: D2000
145: 142 00000d70 * .text
146: 143 00024DB4 dd 8f00000d61 pushl $L240
147: 144 00024DBA fe 08 effffffecb callf $8,_writes
148: 145 00024DC1 # write32h( sgl_ld_acc );
149: 146 00024DC1 dd effffffec5 pushl _sgl_ld_acc
150: 147 00024DC7 fe 08 effffffebe callf $8,_write32h
151: 148 00024DCE # writes(", final Acc = ");
152: 149 00024DCE .data 1
153: 150 00000d70 * L242:
154: 151 00000d70 * 2C202020202066696E616C204 .ascii ", final Acc = \0"
155: 16363203D2000
156: 152 00000d83 * .text
157: 153 00024DCE dd 8f00000d70 pushl $L242
158: 154 00024DD4 fe 08 effffffeb1 callf $8,_writes
159: 155 00024DDB # write32h( sgl_st_acc );
160: 156 00024DDB dd effffffeab pushl _sgl_st_acc
161: 157 00024DE1 fe 08 effffffea4 callf $8,_write32h
162: 158 00024DE8 # writes("\n expected Acc = ");
163: 159 00024DE8 .data 1
164: 160 00000d83 * L243:
165: 161 00000d83 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0"
166: 0202020202020202020202020
167: 2020202065787065637465642
168: 0416363203D2000
169: 162 00000db0 * .text
170: 163 00024DE8 dd 8f00000d83 pushl $L243
171: 164 00024DEE fe 08 effffffe97 callf $8,_writes
172: 165 00024DF5 # write32h( sgl_expected );
173: 166 00024DF5 dd effffffe91 pushl _sgl_expected
174: 167 00024DFB fe 08 effffffe8a callf $8,_write32h
175: 168 00024E02 # writec('\n');
176: 169 00024E02 dd 0a pushl $10
177: 170 00024E04 fe 08 effffffe81 callf $8,_writec
178: 171 00024E0B # }
179: 172 00024E0B # if ( halt_flg ) /* halt on error? */
180: 173 00024E0B L237:
181: 174 00024E0B 5d effffffe7b tstl _halt_flg
182: 175 00024E11 31 09 jeql L245
183: 176 00024E13 # mull3_halt( 4 );
184: 177 00024E13 dd 04 pushl $4
185: 178 00024E15 fe 08 ef00000a4c callf $8,_mull3_halt
186: 179 00024E1C # if ( loop_on_err ) {
187: 180 00024E1C L245:
188: 181 00024E1C 5d effffffe6a tstl _loop_on_err
189: 182 00024E22 31 0d jeql L247
190: 183 00024E24 # force_loop = TRUE; /* set the force loop flag */
191: 184 00024E24 0d 01 effffffe61 movl $1,_force_loop
192: 185 00024E2B # asm("jmp _mull3_1_lp1"); /* and loop */
193: 186 00024E2B 71 efffffff28 jmp _mull3_1_lp1
194: 187 00024E31 # } /* end of loop-on-error */
195: 188 00024E31 # } /* end of acc corr error */
196: 189 00024E31 L247:
197: 190 00024E31 # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
198: 191 00024E31 L236:
199: 192 00024E31 1d effffffe55 effffffe50 cmpl _sgl_value_4,_sgl_value_3
200: 193 00024E3C 31 41 jeql L248
201: 194 00024E3E # {
202: 195 00024E3E # errcnt++; /* bump the error count */
203: 196 00024E3E 6d effffffe48 incl _errcnt
204: 197 00024E44 # if ( prt_error ) {
205: 198 00024E44 5d effffffe42 tstl _prt_error
206: 199 00024E4A 31 0d jeql L249
207: 200 00024E4C # print_mull3_error("(Reg. Data) -BAD MULTIPLY RESULT");
208: 201 00024E4C .data 1
209: 202 00000db0 * L250:
210: 203 00000db0 * 285265672E204461746129202 .ascii "(Reg. Data) -BAD MULTIPLY RESULT\0"
211: D424144204D554C5449504C59
212: 20524553554C5400
213: 204 00000dd1 * .text
214: 205 00024E4C dd 8f00000db0 pushl $L250
215: 206 00024E52 fe 08 ef00000909 callf $8,_print_mull3_error
216: 207 00024E59 # }
217: 208 00024E59 # if ( halt_flg ) /* halt on error? */
218: 209 00024E59 L249:
219: 210 00024E59 5d effffffe2d tstl _halt_flg
220: 211 00024E5F 31 09 jeql L251
221: 212 00024E61 # mull3_halt( 1 );
222: 213 00024E61 dd 01 pushl $1
223: 214 00024E63 fe 08 ef000009fe callf $8,_mull3_halt
224: 215 00024E6A # if ( loop_on_err ) {
225: 216 00024E6A L251:
226: 217 00024E6A 5d effffffe1c tstl _loop_on_err
227: 218 00024E70 31 0d jeql L252
228: 219 00024E72 # force_loop = TRUE; /* set the force loop flag */
229: 220 00024E72 0d 01 effffffe13 movl $1,_force_loop
230: 221 00024E79 # asm("jmp _mull3_1_lp1"); /* and loop */
231: 222 00024E79 71 effffffeda jmp _mull3_1_lp1
232: 223 00024E7F # } /* end of loop-on-error */
233: 224 00024E7F # } /* end of multiply error */
234: 225 00024E7F L252:
235: 226 00024E7F # }
236: 227 00024E7F L248:
237: 228 00024E7F L232:
238: 229 00024E7F 6d effffffe07 incl _index
239: 230 00024E85 13 fe72 jbr L234
240: 231 00024E88 L233:
241: 232 00024E88 # } /* end of subtest 1 */
242: 233 00024E88 40 ret#2
243: 234 00024E89 .set L228,0x0
244: 235 00024E89 L230:
245: 236 00024E89 13 fe5b jbr L231
246: 237 00024E8C .data
247: 238 00000d38 * .text
248: 239 00024E8C .align 1
249: 240 00024E8C .globl _mull3_2
250: 241 00024E8C _mull3_2:
251: 242 00024E8C 0000 .word L253
252: 243 00024E8E #
253: 244 00024E8E #
254: 245 00024E8E #
255: 246 00024E8E # /************************************************************************
256: 247 00024E8E # *
257: 248 00024E8E # * SUBTEST 2 - cache addressing / double precsion accumulator
258: 249 00024E8E # *
259: 250 00024E8E # ************************************************************************/
260: 251 00024E8E # mull3_2()
261: 252 00024E8E # {
262: 253 00024E8E 13 0201 jbr L255
263: 254 00024E91 L256:
264: 255 00024E91 # force_loop = FALSE;
265: 256 00024E91 4d effffffdf5 clrl _force_loop
266: 257 00024E97 # subtest = 2;
267: 258 00024E97 0d 02 effffffdee movl $2,_subtest
268: 259 00024E9E # for( index = 0; index < max_mull_1_index; index++ ) {
269: 260 00024E9E 4d effffffde8 clrl _index
270: 261 00024EA4 L259:
271: 262 00024EA4 1d effffffde2 effffffddd cmpl _index,_max_mull_1_index
272: 263 00024EAF 91 03 13 01dd jgeq L258
273: 264 00024EB4 # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
274: 265 00024EB4 5c 0c effffffdd1 50 mull3 $12,_index,r0
275: 266 00024EBC 0d e000000000 effffffdc5 movl _mull_1_data(r0),_sgl_value_1
276: 267 00024EC7 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
277: 268 00024EC7 5c 0c effffffdbe 50 mull3 $12,_index,r0
278: 269 00024ECF 0d e000000004 effffffdb2 movl _mull_1_data+4(r0),_sgl_value_2
279: 270 00024EDA # sgl_value_4 = mull_1_data[index].exp; /* get expected results */
280: 271 00024EDA 5c 0c effffffdab 50 mull3 $12,_index,r0
281: 272 00024EE2 0d e000000008 effffffd9f movl _mull_1_data+8(r0),_sgl_value_4
282: 273 00024EED # dbl_ld_acc.m = 0x12345678; /* set acc data pattern */
283: 274 00024EED 0d 8f12345678 effffffd94 movl $305419896,_dbl_ld_acc
284: 275 00024EF8 # dbl_ld_acc.l = 0x9abcdef0;
285: 276 00024EF8 0d 8f9abcdef0 effffffd8d movl $-1698898192,_dbl_ld_acc+4
286: 277 00024F03 # dbl_expected.m = dbl_ld_acc.m; /* final Acc expected */
287: 278 00024F03 0d effffffd83 effffffd7e movl _dbl_ld_acc,_dbl_expected
288: 279 00024F0E # dbl_expected.l = dbl_ld_acc.l;
289: 280 00024F0E 0d effffffd7c effffffd77 movl _dbl_ld_acc+4,_dbl_expected+4
290: 281 00024F19 # /*
291: 282 00024F19 # * If LOOP ON ERROR is set, this is the loop for this subtest.
292: 283 00024F19 # */
293: 284 00024F19 # asm("_mull3_2_lp1:");
294: 285 00024F19 _mull3_2_lp1:
295: 286 00024F19 # asm("ldd _dbl_ld_acc"); /* load the acc */
296: 287 00024F19 07 effffffd6d ldd _dbl_ld_acc
297: 288 00024F1F # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
298: 289 00024F1F 5c effffffd67 effffffd62 mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3
299: effffffd5d
300: 290 00024F2F # asm("nop");
301: 291 00024F2F 10 nop
302: 292 00024F30 # asm("std _dbl_st_acc"); /* save the acc */
303: 293 00024F30 27 effffffd56 std _dbl_st_acc
304: 294 00024F36 # if( force_loop )
305: 295 00024F36 5d effffffd50 tstl _force_loop
306: 296 00024F3C 31 02 jeql L260
307: 297 00024F3E # asm("brb _mull3_2_lp1");;
308: 298 00024F3E 11 d9 brb _mull3_2_lp1
309: 299 00024F40 L260:
310: 300 00024F40 # if( (dbl_expected.m != dbl_st_acc.m) || /* COMPARE the Acc */
311: 301 00024F40 # (dbl_expected.l != dbl_st_acc.l) ) {
312: 302 00024F40 1d effffffd46 effffffd41 cmpl _dbl_expected,_dbl_st_acc
313: 303 00024F4B 21 10 jneq L9999
314: 304 00024F4D 1d effffffd3d effffffd38 cmpl _dbl_expected+4,_dbl_st_acc+4
315: 305 00024F58 21 03 13 00dd jeql L261
316: 306 00024F5D L9999:
317: 307 00024F5D # errcnt++; /* bump the error count */
318: 308 00024F5D 6d effffffd29 incl _errcnt
319: 309 00024F63 # if ( prt_error ) {
320: 310 00024F63 5d effffffd23 tstl _prt_error
321: 311 00024F69 21 03 13 00a6 jeql L262
322: 312 00024F6E # print_mull3_error("(Memory data) -THE ACC WAS MODIFIED");
323: 313 00024F6E .data 1
324: 314 00000dd1 * L263:
325: 315 00000dd1 * 284D656D6F727920646174612 .ascii "(Memory data) -THE ACC WAS MODIFIED\0"
326: 9202D54484520414343205741
327: 53204D4F44494649454400
328: 316 00000df5 * .text
329: 317 00024F6E dd 8f00000dd1 pushl $L263
330: 318 00024F74 fe 08 ef000007e7 callf $8,_print_mull3_error
331: 319 00024F7B # writes("initial Acc = ");
332: 320 00024F7B .data 1
333: 321 00000df5 * L264:
334: 322 00000df5 * 696E697469616C20416363203 .ascii "initial Acc = \0"
335: D2000
336: 323 00000e04 * .text
337: 324 00024F7B dd 8f00000df5 pushl $L264
338: 325 00024F81 fe 08 effffffd04 callf $8,_writes
339: 326 00024F88 # write32h( dbl_ld_acc.m );
340: 327 00024F88 dd effffffcfe pushl _dbl_ld_acc
341: 328 00024F8E fe 08 effffffcf7 callf $8,_write32h
342: 329 00024F95 # writec(' ');
343: 330 00024F95 dd 20 pushl $32
344: 331 00024F97 fe 08 effffffcee callf $8,_writec
345: 332 00024F9E # write32h( dbl_ld_acc.l );
346: 333 00024F9E dd effffffcec pushl _dbl_ld_acc+4
347: 334 00024FA4 fe 08 effffffce1 callf $8,_write32h
348: 335 00024FAB # writes(", final Acc = ");
349: 336 00024FAB .data 1
350: 337 00000e04 * L265:
351: 338 00000e04 * 2C202020202066696E616C204 .ascii ", final Acc = \0"
352: 16363203D2000
353: 339 00000e17 * .text
354: 340 00024FAB dd 8f00000e04 pushl $L265
355: 341 00024FB1 fe 08 effffffcd4 callf $8,_writes
356: 342 00024FB8 # write32h( dbl_st_acc.m );
357: 343 00024FB8 dd effffffcce pushl _dbl_st_acc
358: 344 00024FBE fe 08 effffffcc7 callf $8,_write32h
359: 345 00024FC5 # writec(' ');
360: 346 00024FC5 dd 20 pushl $32
361: 347 00024FC7 fe 08 effffffcbe callf $8,_writec
362: 348 00024FCE # write32h( dbl_st_acc.l );
363: 349 00024FCE dd effffffcbc pushl _dbl_st_acc+4
364: 350 00024FD4 fe 08 effffffcb1 callf $8,_write32h
365: 351 00024FDB # writes("\n expected Acc = ");
366: 352 00024FDB .data 1
367: 353 00000e17 * L266:
368: 354 00000e17 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0"
369: 0202020202020202020202020
370: 2020202020202020202065787
371: 0656374656420416363203D20
372: 00
373: 355 00000e4a * .text
374: 356 00024FDB dd 8f00000e17 pushl $L266
375: 357 00024FE1 fe 08 effffffca4 callf $8,_writes
376: 358 00024FE8 # write32h( dbl_expected.m );
377: 359 00024FE8 dd effffffc9e pushl _dbl_expected
378: 360 00024FEE fe 08 effffffc97 callf $8,_write32h
379: 361 00024FF5 # writec(' ');
380: 362 00024FF5 dd 20 pushl $32
381: 363 00024FF7 fe 08 effffffc8e callf $8,_writec
382: 364 00024FFE # write32h( dbl_expected.l );
383: 365 00024FFE dd effffffc8c pushl _dbl_expected+4
384: 366 00025004 fe 08 effffffc81 callf $8,_write32h
385: 367 0002500B # writec('\n');
386: 368 0002500B dd 0a pushl $10
387: 369 0002500D fe 08 effffffc78 callf $8,_writec
388: 370 00025014 # }
389: 371 00025014 # if ( halt_flg ) /* halt on error? */
390: 372 00025014 L262:
391: 373 00025014 5d effffffc72 tstl _halt_flg
392: 374 0002501A 31 09 jeql L267
393: 375 0002501C # mull3_halt( 4 );
394: 376 0002501C dd 04 pushl $4
395: 377 0002501E fe 08 ef00000843 callf $8,_mull3_halt
396: 378 00025025 # if ( loop_on_err ) {
397: 379 00025025 L267:
398: 380 00025025 5d effffffc61 tstl _loop_on_err
399: 381 0002502B 31 0d jeql L268
400: 382 0002502D # force_loop = TRUE; /* set the force loop flag */
401: 383 0002502D 0d 01 effffffc58 movl $1,_force_loop
402: 384 00025034 # asm("jmp _mull3_2_lp1"); /* and loop */
403: 385 00025034 71 effffffedf jmp _mull3_2_lp1
404: 386 0002503A # } /* end of loop-on-error */
405: 387 0002503A # } /* end of acc corr error */
406: 388 0002503A L268:
407: 389 0002503A # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
408: 390 0002503A L261:
409: 391 0002503A 1d effffffc4c effffffc47 cmpl _sgl_value_4,_sgl_value_3
410: 392 00025045 31 41 jeql L269
411: 393 00025047 # {
412: 394 00025047 # errcnt++; /* bump the error count */
413: 395 00025047 6d effffffc3f incl _errcnt
414: 396 0002504D # if ( prt_error ) {
415: 397 0002504D 5d effffffc39 tstl _prt_error
416: 398 00025053 31 0d jeql L270
417: 399 00025055 # print_mull3_error("(Memory data) -BAD MULTIPLY RESULT");
418: 400 00025055 .data 1
419: 401 00000e4a * L271:
420: 402 00000e4a * 284D656D6F727920646174612 .ascii "(Memory data) -BAD MULTIPLY RESULT\0"
421: 9202D424144204D554C544950
422: 4C5920524553554C5400
423: 403 00000e6d * .text
424: 404 00025055 dd 8f00000e4a pushl $L271
425: 405 0002505B fe 08 ef00000700 callf $8,_print_mull3_error
426: 406 00025062 # }
427: 407 00025062 # if ( halt_flg ) /* halt on error? */
428: 408 00025062 L270:
429: 409 00025062 5d effffffc24 tstl _halt_flg
430: 410 00025068 31 09 jeql L272
431: 411 0002506A # mull3_halt( 1 );
432: 412 0002506A dd 01 pushl $1
433: 413 0002506C fe 08 ef000007f5 callf $8,_mull3_halt
434: 414 00025073 # if ( loop_on_err ) {
435: 415 00025073 L272:
436: 416 00025073 5d effffffc13 tstl _loop_on_err
437: 417 00025079 31 0d jeql L273
438: 418 0002507B # force_loop = TRUE; /* set the force loop flag */
439: 419 0002507B 0d 01 effffffc0a movl $1,_force_loop
440: 420 00025082 # asm("jmp _mull3_2_lp1"); /* and loop */
441: 421 00025082 71 effffffe91 jmp _mull3_2_lp1
442: 422 00025088 # } /* end of loop-on-error */
443: 423 00025088 # } /* end of multiply error */
444: 424 00025088 L273:
445: 425 00025088 # }
446: 426 00025088 L269:
447: 427 00025088 L257:
448: 428 00025088 6d effffffbfe incl _index
449: 429 0002508E 13 fe13 jbr L259
450: 430 00025091 L258:
451: 431 00025091 # } /* end of subtest 2 */
452: 432 00025091 40 ret#2
453: 433 00025092 .set L253,0x0
454: 434 00025092 L255:
455: 435 00025092 13 fdfc jbr L256
456: 436 00025095 .data
457: 437 00000d38 * .text
458: 438 00025095 00 .align 1
459: 439 00025096 .globl _mull3_3
460: 440 00025096 _mull3_3:
461: 441 00025096 0000 .word L274
462: 442 00025098 #
463: 443 00025098 #
464: 444 00025098 #
465: 445 00025098 # /************************************************************************
466: 446 00025098 # *
467: 447 00025098 # * SUBTEST 3 - register corruption test
468: 448 00025098 # *
469: 449 00025098 # ************************************************************************/
470: 450 00025098 # mull3_3()
471: 451 00025098 # {
472: 452 00025098 13 0188 jbr L276
473: 453 0002509B L277:
474: 454 0002509B # force_loop = FALSE;
475: 455 0002509B 4d effffffbeb clrl _force_loop
476: 456 000250A1 # subtest = 2;
477: 457 000250A1 0d 02 effffffbe4 movl $2,_subtest
478: 458 000250A8 # fill_reg_buf( load_regs ); /* get pattern for registers */
479: 459 000250A8 dd 8f00000000 pushl $_load_regs
480: 460 000250AE fe 08 effffffbd7 callf $8,_fill_reg_buf
481: 461 000250B5 # for( index = 0; index < max_mull_1_index; index++ ) {
482: 462 000250B5 4d effffffbd1 clrl _index
483: 463 000250BB L281:
484: 464 000250BB 1d effffffbcb effffffbc6 cmpl _index,_max_mull_1_index
485: 465 000250C6 91 03 13 0157 jgeq L280
486: 466 000250CB # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
487: 467 000250CB 5c 0c effffffbba 50 mull3 $12,_index,r0
488: 468 000250D3 0d e000000000 effffffbae movl _mull_1_data(r0),_sgl_value_1
489: 469 000250DE # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
490: 470 000250DE 5c 0c effffffba7 50 mull3 $12,_index,r0
491: 471 000250E6 0d e000000004 effffffb9b movl _mull_1_data+4(r0),_sgl_value_2
492: 472 000250F1 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */
493: 473 000250F1 5c 0c effffffb94 50 mull3 $12,_index,r0
494: 474 000250F9 0d e000000008 effffffb88 movl _mull_1_data+8(r0),_sgl_value_4
495: 475 00025104 # /*
496: 476 00025104 # * If LOOP ON ERROR is set, this is the loop for this subtest.
497: 477 00025104 # */
498: 478 00025104 # asm("_mull3_3_lp1:");
499: 479 00025104 _mull3_3_lp1:
500: 480 00025104 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
501: 481 00025104 ab 891fff effffffb7f loadr $0x1fff,_load_regs
502: 482 0002510D # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
503: 483 0002510D 5c effffffb79 effffffb74 mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3
504: effffffb6f
505: 484 0002511D # asm("nop");
506: 485 0002511D 10 nop
507: 486 0002511E # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
508: 487 0002511E bb 891fff effffffb65 storer $0x1fff,_store_regs
509: 488 00025127 # if( force_loop )
510: 489 00025127 5d effffffb5f tstl _force_loop
511: 490 0002512D 31 02 jeql L282
512: 491 0002512F # asm("brb _mull3_3_lp1");
513: 492 0002512F 11 d3 brb _mull3_3_lp1
514: 493 00025131 # /*
515: 494 00025131 # * Now check the result
516: 495 00025131 # */
517: 496 00025131 # index2 = 0;
518: 497 00025131 L282:
519: 498 00025131 4d effffffb55 clrl _index2
520: 499 00025137 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
521: 500 00025137 L283:
522: 501 00025137 0d effffffb4f 50 movl _index2,r0
523: 502 0002513E 0d effffffb48 51 movl _index2,r1
524: 503 00025145 1d 40effffffb40 cmpl _load_regs[r0],_store_regs[r1]
525: 41effffffb3a
526: 504 00025152 21 11 jneq L284
527: 505 00025154 1d effffffb32 0d cmpl _index2,$13
528: 506 0002515B 81 08 jgeq L284
529: 507 0002515D # index2++; /* check reg values */
530: 508 0002515D 6d effffffb29 incl _index2
531: 509 00025163 11 d2 jbr L283
532: 510 00025165 L284:
533: 511 00025165 # if( index2 < 13 ) { /* error if index2 < 13 */
534: 512 00025165 1d effffffb21 0d cmpl _index2,$13
535: 513 0002516C 91 03 13 00a8 jgeq L285
536: 514 00025171 # errcnt++; /* bump the error count */
537: 515 00025171 6d effffffb15 incl _errcnt
538: 516 00025177 # if ( prt_error ) {
539: 517 00025177 5d effffffb0f tstl _prt_error
540: 518 0002517D 31 74 jeql L286
541: 519 0002517F # print_mull3_error(" -A REGISTER WAS MODIFIED");
542: 520 0002517F .data 1
543: 521 00000e6d * L287:
544: 522 00000e6d * 202D412052454749535445522 .ascii " -A REGISTER WAS MODIFIED\0"
545: 0574153204D4F444946494544
546: 00
547: 523 00000e87 * .text
548: 524 0002517F dd 8f00000e6d pushl $L287
549: 525 00025185 fe 08 ef000005d6 callf $8,_print_mull3_error
550: 526 0002518C # writes("register ");
551: 527 0002518C .data 1
552: 528 00000e87 * L288:
553: 529 00000e87 * 72656769737465722000 .ascii "register \0"
554: 530 00000e91 * .text
555: 531 0002518C dd 8f00000e87 pushl $L288
556: 532 00025192 fe 08 effffffaf3 callf $8,_writes
557: 533 00025199 # writeh( index2 );
558: 534 00025199 dd effffffaed pushl _index2
559: 535 0002519F fe 08 effffffae6 callf $8,_writeh
560: 536 000251A6 # writes(" = ");
561: 537 000251A6 .data 1
562: 538 00000e91 * L290:
563: 539 00000e91 * 203D2000 .ascii " = \0"
564: 540 00000e95 * .text
565: 541 000251A6 dd 8f00000e91 pushl $L290
566: 542 000251AC fe 08 effffffad9 callf $8,_writes
567: 543 000251B3 # write32h( store_regs[index2] );
568: 544 000251B3 0d effffffad3 50 movl _index2,r0
569: 545 000251BA dd 40effffffacb pushl _store_regs[r0]
570: 546 000251C1 fe 08 effffffac4 callf $8,_write32h
571: 547 000251C8 # writes(", should be = ");
572: 548 000251C8 .data 1
573: 549 00000e95 * L291:
574: 550 00000e95 * 2C202073686F756C642062652 .ascii ", should be = \0"
575: 03D2000
576: 551 00000ea5 * .text
577: 552 000251C8 dd 8f00000e95 pushl $L291
578: 553 000251CE fe 08 effffffab7 callf $8,_writes
579: 554 000251D5 # write32h( load_regs[index2] );
580: 555 000251D5 0d effffffab1 50 movl _index2,r0
581: 556 000251DC dd 40effffffaa9 pushl _load_regs[r0]
582: 557 000251E3 fe 08 effffffaa2 callf $8,_write32h
583: 558 000251EA # writec('\n');
584: 559 000251EA dd 0a pushl $10
585: 560 000251EC fe 08 effffffa99 callf $8,_writec
586: 561 000251F3 # }
587: 562 000251F3 # if ( halt_flg ) /* halt on error? */
588: 563 000251F3 L286:
589: 564 000251F3 5d effffffa93 tstl _halt_flg
590: 565 000251F9 31 09 jeql L292
591: 566 000251FB # mull3_halt( 2 );
592: 567 000251FB dd 02 pushl $2
593: 568 000251FD fe 08 ef00000664 callf $8,_mull3_halt
594: 569 00025204 # if ( loop_on_err ) {
595: 570 00025204 L292:
596: 571 00025204 5d effffffa82 tstl _loop_on_err
597: 572 0002520A 31 0d jeql L293
598: 573 0002520C # force_loop = TRUE; /* set the force loop flag */
599: 574 0002520C 0d 01 effffffa79 movl $1,_force_loop
600: 575 00025213 # asm("jmp _mull3_3_lp1"); /* and loop */
601: 576 00025213 71 effffffeeb jmp _mull3_3_lp1
602: 577 00025219 # }; /* end of loop-on-error */
603: 578 00025219 L293:
604: 579 00025219 # } /* end of multiply error */
605: 580 00025219 # }
606: 581 00025219 L285:
607: 582 00025219 L279:
608: 583 00025219 6d effffffa6d incl _index
609: 584 0002521F 13 fe99 jbr L281
610: 585 00025222 L280:
611: 586 00025222 # } /* end of subtest 3 */
612: 587 00025222 40 ret#2
613: 588 00025223 .set L274,0x0
614: 589 00025223 L276:
615: 590 00025223 13 fe75 jbr L277
616: 591 00025226 .data
617: 592 00000d38 * .text
618: 593 00025226 .align 1
619: 594 00025226 .globl _mull3_4
620: 595 00025226 _mull3_4:
621: 596 00025226 0000 .word L294
622: 597 00025228 #
623: 598 00025228 #
624: 599 00025228 #
625: 600 00025228 # /************************************************************************
626: 601 00025228 # *
627: 602 00025228 # * SUBTEST 4 - PSL corruption test
628: 603 00025228 # *
629: 604 00025228 # ************************************************************************/
630: 605 00025228 # mull3_4()
631: 606 00025228 # {
632: 607 00025228 13 019c jbr L296
633: 608 0002522B L297:
634: 609 0002522B # force_loop = FALSE;
635: 610 0002522B 4d effffffa5b clrl _force_loop
636: 611 00025231 # subtest = 4;
637: 612 00025231 0d 04 effffffa54 movl $4,_subtest
638: 613 00025238 # status_index = 0;
639: 614 00025238 4d effffffa4e clrl _status_index
640: 615 0002523E # for( index = 0; index < max_mull_1_index; index++ ) {
641: 616 0002523E 4d effffffa48 clrl _index
642: 617 00025244 L300:
643: 618 00025244 1d effffffa42 effffffa3d cmpl _index,_max_mull_1_index
644: 619 0002524F 91 03 13 0172 jgeq L299
645: 620 00025254 # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
646: 621 00025254 5c 0c effffffa31 50 mull3 $12,_index,r0
647: 622 0002525C 0d e000000000 effffffa25 movl _mull_1_data(r0),_sgl_value_1
648: 623 00025267 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
649: 624 00025267 5c 0c effffffa1e 50 mull3 $12,_index,r0
650: 625 0002526F 0d e000000004 effffffa12 movl _mull_1_data+4(r0),_sgl_value_2
651: 626 0002527A # sgl_value_4 = mull_1_data[index].exp; /* get expected results */
652: 627 0002527A 5c 0c effffffa0b 50 mull3 $12,_index,r0
653: 628 00025282 0d e000000008 effffff9ff movl _mull_1_data+8(r0),_sgl_value_4
654: 629 0002528D # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
655: 630 0002528D 0d effffff9f9 50 movl _status_index,r0
656: 631 00025294 0d 40effffff9f1 movl _status_array[r0],_sgl_dummy1
657: effffff9ec
658: 632 000252A0 # /*
659: 633 000252A0 # * If LOOP ON ERROR is set, this is the loop for this subtest.
660: 634 000252A0 # */
661: 635 000252A0 # asm("_mull3_4_lp1:");
662: 636 000252A0 _mull3_4_lp1:
663: 637 000252A0 # asm("tstl _sgl_dummy1");
664: 638 000252A0 5d effffff9e6 tstl _sgl_dummy1
665: 639 000252A6 # asm("movpsl _init_psl"); /* save the initial PSL */
666: 640 000252A6 cd effffff9e0 movpsl _init_psl
667: 641 000252AC # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
668: 642 000252AC 5c effffff9da effffff9d5 mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3
669: effffff9d0
670: 643 000252BC # asm("movpsl _psl_val"); /* save the final PSL */
671: 644 000252BC cd effffff9ca movpsl _psl_val
672: 645 000252C2 # if( force_loop )
673: 646 000252C2 5d effffff9c4 tstl _force_loop
674: 647 000252C8 31 02 jeql L301
675: 648 000252CA # asm("brb _mull3_4_lp1");
676: 649 000252CA 11 d4 brb _mull3_4_lp1
677: 650 000252CC # /*
678: 651 000252CC # * Now check the result
679: 652 000252CC # */
680: 653 000252CC # exp_psl = init_psl & 0xffffff3; /* strip off the PSL status */
681: 654 000252CC L301:
682: 655 000252CC bc 8f0ffffff3 effffff9b5 andl3 $268435443,_init_psl,r0
683: 50
684: 656 000252D8 0d 50 effffff9ad movl r0,_exp_psl
685: 657 000252DF # if( sgl_value_4 < 0 ) /* check the MULL result */
686: 658 000252DF 5d effffff9a7 tstl _sgl_value_4
687: 659 000252E5 81 07 jgeq L302
688: 660 000252E7 # exp_psl |= PSL_N; /* set the NEGATIVE bit */
689: 661 000252E7 8c 08 effffff99e orl2 $8,_exp_psl
690: 662 000252EE # if( !sgl_value_4 )
691: 663 000252EE L302:
692: 664 000252EE 5d effffff998 tstl _sgl_value_4
693: 665 000252F4 21 07 jneq L303
694: 666 000252F6 # exp_psl |= PSL_Z; /* set the ZERO bit */
695: 667 000252F6 8c 04 effffff98f orl2 $4,_exp_psl
696: 668 000252FD # if( psl_val != exp_psl ) { /* was the final PSL correct */
697: 669 000252FD L303:
698: 670 000252FD 1d effffff989 effffff984 cmpl _psl_val,_exp_psl
699: 671 00025308 21 03 13 0098 jeql L304
700: 672 0002530D # errcnt++; /* bump the error count */
701: 673 0002530D 6d effffff979 incl _errcnt
702: 674 00025313 # if ( prt_error ) {
703: 675 00025313 5d effffff973 tstl _prt_error
704: 676 00025319 31 64 jeql L305
705: 677 0002531B # print_mull3_error(" -INCORRECT FINAL PSL");
706: 678 0002531B .data 1
707: 679 00000ea5 * L306:
708: 680 00000ea5 * 202D494E434F5252454354204 .ascii " -INCORRECT FINAL PSL\0"
709: 6494E414C2050534C00
710: 681 00000ebb * .text
711: 682 0002531B dd 8f00000ea5 pushl $L306
712: 683 00025321 fe 08 ef0000043a callf $8,_print_mull3_error
713: 684 00025328 # writes("initial PSL = ");
714: 685 00025328 .data 1
715: 686 00000ebb * L307:
716: 687 00000ebb * 696E697469616C2050534C203 .ascii "initial PSL = \0"
717: D2000
718: 688 00000eca * .text
719: 689 00025328 dd 8f00000ebb pushl $L307
720: 690 0002532E fe 08 effffff957 callf $8,_writes
721: 691 00025335 # write32h( init_psl );
722: 692 00025335 dd effffff951 pushl _init_psl
723: 693 0002533B fe 08 effffff94a callf $8,_write32h
724: 694 00025342 # writes(", final PSL = ");
725: 695 00025342 .data 1
726: 696 00000eca * L308:
727: 697 00000eca * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
728: 03D2000
729: 698 00000eda * .text
730: 699 00025342 dd 8f00000eca pushl $L308
731: 700 00025348 fe 08 effffff93d callf $8,_writes
732: 701 0002534F # write32h( psl_val );
733: 702 0002534F dd effffff937 pushl _psl_val
734: 703 00025355 fe 08 effffff930 callf $8,_write32h
735: 704 0002535C # writes(", expected PSL = ");
736: 705 0002535C .data 1
737: 706 00000eda * L309:
738: 707 00000eda * 2C20206578706563746564205 .ascii ", expected PSL = \0"
739: 0534C203D2000
740: 708 00000eed * .text
741: 709 0002535C dd 8f00000eda pushl $L309
742: 710 00025362 fe 08 effffff923 callf $8,_writes
743: 711 00025369 # write32h( exp_psl );
744: 712 00025369 dd effffff91d pushl _exp_psl
745: 713 0002536F fe 08 effffff916 callf $8,_write32h
746: 714 00025376 # writec('\n');
747: 715 00025376 dd 0a pushl $10
748: 716 00025378 fe 08 effffff90d callf $8,_writec
749: 717 0002537F # }
750: 718 0002537F # if ( halt_flg ) /* halt on error? */
751: 719 0002537F L305:
752: 720 0002537F 5d effffff907 tstl _halt_flg
753: 721 00025385 31 09 jeql L310
754: 722 00025387 # mull3_halt( 3 );
755: 723 00025387 dd 03 pushl $3
756: 724 00025389 fe 08 ef000004d8 callf $8,_mull3_halt
757: 725 00025390 # if ( loop_on_err ) {
758: 726 00025390 L310:
759: 727 00025390 5d effffff8f6 tstl _loop_on_err
760: 728 00025396 31 0d jeql L311
761: 729 00025398 # force_loop = TRUE; /* set the force loop flag */
762: 730 00025398 0d 01 effffff8ed movl $1,_force_loop
763: 731 0002539F # asm("jmp _mull3_4_lp1"); /* and loop */
764: 732 0002539F 71 effffffefb jmp _mull3_4_lp1
765: 733 000253A5 # }; /* end of loop-on-error */
766: 734 000253A5 L311:
767: 735 000253A5 # }; /* end of error */
768: 736 000253A5 L304:
769: 737 000253A5 # if( ++status_index >= 3 )
770: 738 000253A5 6d effffff8e1 incl _status_index
771: 739 000253AB 0d effffff8db 50 movl _status_index,r0
772: 740 000253B2 1d 50 03 cmpl r0,$3
773: 741 000253B5 91 06 jlss L312
774: 742 000253B7 # status_index = 0;
775: 743 000253B7 4d effffff8cf clrl _status_index
776: 744 000253BD # }
777: 745 000253BD L312:
778: 746 000253BD L298:
779: 747 000253BD 6d effffff8c9 incl _index
780: 748 000253C3 13 fe7e jbr L300
781: 749 000253C6 L299:
782: 750 000253C6 # } /* end of subtest 4 */
783: 751 000253C6 40 ret#2
784: 752 000253C7 .set L294,0x0
785: 753 000253C7 L296:
786: 754 000253C7 13 fe61 jbr L297
787: 755 000253CA .data
788: 756 00000d38 * .text
789: 757 000253CA .align 1
790: 758 000253CA .globl _mull3_5
791: 759 000253CA _mull3_5:
792: 760 000253CA 0000 .word L313
793: 761 000253CC #
794: 762 000253CC #
795: 763 000253CC #
796: 764 000253CC # /************************************************************************
797: 765 000253CC # *
798: 766 000253CC # * SUBTEST 5 - Pipelined Entry test
799: 767 000253CC # *
800: 768 000253CC # ************************************************************************/
801: 769 000253CC # mull3_5()
802: 770 000253CC # {
803: 771 000253CC 13 01c3 jbr L315
804: 772 000253CF L316:
805: 773 000253CF # force_loop = FALSE;
806: 774 000253CF 4d effffff8b7 clrl _force_loop
807: 775 000253D5 # subtest = 5;
808: 776 000253D5 0d 05 effffff8b0 movl $5,_subtest
809: 777 000253DC # for( index = 0; index < max_mull_1_index; index++ ) {
810: 778 000253DC 4d effffff8aa clrl _index
811: 779 000253E2 L319:
812: 780 000253E2 1d effffff8a4 effffff89f cmpl _index,_max_mull_1_index
813: 781 000253ED 91 03 13 019f jgeq L318
814: 782 000253F2 # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
815: 783 000253F2 5c 0c effffff893 50 mull3 $12,_index,r0
816: 784 000253FA 0d e000000000 effffff887 movl _mull_1_data(r0),_sgl_value_1
817: 785 00025405 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
818: 786 00025405 5c 0c effffff880 50 mull3 $12,_index,r0
819: 787 0002540D 0d e000000004 effffff874 movl _mull_1_data+4(r0),_sgl_value_2
820: 788 00025418 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */
821: 789 00025418 5c 0c effffff86d 50 mull3 $12,_index,r0
822: 790 00025420 0d e000000008 effffff861 movl _mull_1_data+8(r0),_sgl_value_4
823: 791 0002542B # sgl_ld_acc = 0x12345678; /* set acc data pattern */
824: 792 0002542B 0d 8f12345678 effffff856 movl $305419896,_sgl_ld_acc
825: 793 00025436 # sgl_expected = sgl_ld_acc; /* final Acc expected */
826: 794 00025436 0d effffff850 effffff84b movl _sgl_ld_acc,_sgl_expected
827: 795 00025441 # sgl_value_10 = 0x40800000; /* floating "1.0" */
828: 796 00025441 0d 8f40800000 effffff840 movl $1082130432,_sgl_value_10
829: 797 0002544C # /*
830: 798 0002544C # * If LOOP ON ERROR is set, this is the loop for this subtest.
831: 799 0002544C # */
832: 800 0002544C # asm("_mull3_5_lp1:");
833: 801 0002544C _mull3_5_lp1:
834: 802 0002544C # asm("ldf _sgl_ld_acc"); /* load the acc */
835: 803 0002544C 06 effffff83a ldf _sgl_ld_acc
836: 804 00025452 # asm("mulf _sgl_value_10"); /* do a floating multiply */
837: 805 00025452 e6 effffff834 mulf _sgl_value_10
838: 806 00025458 # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
839: 807 00025458 5c effffff82e effffff829 mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3
840: effffff824
841: 808 00025468 # asm("stf _sgl_st_acc"); /* save the acc */
842: 809 00025468 26 effffff81e stf _sgl_st_acc
843: 810 0002546E # if( force_loop )
844: 811 0002546E 5d effffff818 tstl _force_loop
845: 812 00025474 31 02 jeql L320
846: 813 00025476 # asm("brb _mull3_5_lp1");;
847: 814 00025476 11 d4 brb _mull3_5_lp1
848: 815 00025478 L320:
849: 816 00025478 # if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */
850: 817 00025478 1d effffff80e effffff809 cmpl _sgl_expected,_sgl_st_acc
851: 818 00025483 21 03 13 00b2 jeql L321
852: 819 00025488 # errcnt++; /* bump the error count */
853: 820 00025488 6d effffff7fe incl _errcnt
854: 821 0002548E # if ( prt_error ) {
855: 822 0002548E 5d effffff7f8 tstl _prt_error
856: 823 00025494 31 7e jeql L322
857: 824 00025496 # print_mull3_error("(Piped Entry) -BAD FINAL ACC");
858: 825 00025496 .data 1
859: 826 00000eed * L323:
860: 827 00000eed * 28506970656420456E7472792 .ascii "(Piped Entry) -BAD FINAL ACC\0"
861: 9202D4241442046494E414C20
862: 41434300
863: 828 00000f0a * .text
864: 829 00025496 dd 8f00000eed pushl $L323
865: 830 0002549C fe 08 ef000002bf callf $8,_print_mull3_error
866: 831 000254A3 # writes("initial Acc = ");
867: 832 000254A3 .data 1
868: 833 00000f0a * L324:
869: 834 00000f0a * 696E697469616C20416363203 .ascii "initial Acc = \0"
870: D2000
871: 835 00000f19 * .text
872: 836 000254A3 dd 8f00000f0a pushl $L324
873: 837 000254A9 fe 08 effffff7dc callf $8,_writes
874: 838 000254B0 # write32h( sgl_ld_acc );
875: 839 000254B0 dd effffff7d6 pushl _sgl_ld_acc
876: 840 000254B6 fe 08 effffff7cf callf $8,_write32h
877: 841 000254BD # writes(", final Acc = ");
878: 842 000254BD .data 1
879: 843 00000f19 * L325:
880: 844 00000f19 * 2C202020202066696E616C204 .ascii ", final Acc = \0"
881: 16363203D2000
882: 845 00000f2c * .text
883: 846 000254BD dd 8f00000f19 pushl $L325
884: 847 000254C3 fe 08 effffff7c2 callf $8,_writes
885: 848 000254CA # write32h( sgl_st_acc );
886: 849 000254CA dd effffff7bc pushl _sgl_st_acc
887: 850 000254D0 fe 08 effffff7b5 callf $8,_write32h
888: 851 000254D7 # writes("\nFPP operand = ");
889: 852 000254D7 .data 1
890: 853 00000f2c * L326:
891: 854 00000f2c * 0A465050206F706572616E642 .ascii "\12FPP operand = \0"
892: 03D2000
893: 855 00000f3c * .text
894: 856 000254D7 dd 8f00000f2c pushl $L326
895: 857 000254DD fe 08 effffff7a8 callf $8,_writes
896: 858 000254E4 # write32h( sgl_value_10 );
897: 859 000254E4 dd effffff7a2 pushl _sgl_value_10
898: 860 000254EA fe 08 effffff79b callf $8,_write32h
899: 861 000254F1 # writes(", expected Acc = ");
900: 862 000254F1 .data 1
901: 863 00000f3c * L327:
902: 864 00000f3c * 2C20206578706563746564204 .ascii ", expected Acc = \0"
903: 16363203D2000
904: 865 00000f4f * .text
905: 866 000254F1 dd 8f00000f3c pushl $L327
906: 867 000254F7 fe 08 effffff78e callf $8,_writes
907: 868 000254FE # write32h( sgl_expected );
908: 869 000254FE dd effffff788 pushl _sgl_expected
909: 870 00025504 fe 08 effffff781 callf $8,_write32h
910: 871 0002550B # writec('\n');
911: 872 0002550B dd 0a pushl $10
912: 873 0002550D fe 08 effffff778 callf $8,_writec
913: 874 00025514 # }
914: 875 00025514 # if ( halt_flg ) /* halt on error? */
915: 876 00025514 L322:
916: 877 00025514 5d effffff772 tstl _halt_flg
917: 878 0002551A 31 09 jeql L328
918: 879 0002551C # mull3_halt( 5 );
919: 880 0002551C dd 05 pushl $5
920: 881 0002551E fe 08 ef00000343 callf $8,_mull3_halt
921: 882 00025525 # if ( loop_on_err ) {
922: 883 00025525 L328:
923: 884 00025525 5d effffff761 tstl _loop_on_err
924: 885 0002552B 31 0d jeql L329
925: 886 0002552D # force_loop = TRUE; /* set the force loop flag */
926: 887 0002552D 0d 01 effffff758 movl $1,_force_loop
927: 888 00025534 # asm("jmp _mull3_5_lp1"); /* and loop */
928: 889 00025534 71 efffffff12 jmp _mull3_5_lp1
929: 890 0002553A # } /* end of loop-on-error */
930: 891 0002553A # } /* end of acc corr error */
931: 892 0002553A L329:
932: 893 0002553A # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
933: 894 0002553A L321:
934: 895 0002553A 1d effffff74c effffff747 cmpl _sgl_value_4,_sgl_value_3
935: 896 00025545 31 41 jeql L330
936: 897 00025547 # {
937: 898 00025547 # errcnt++; /* bump the error count */
938: 899 00025547 6d effffff73f incl _errcnt
939: 900 0002554D # if ( prt_error ) {
940: 901 0002554D 5d effffff739 tstl _prt_error
941: 902 00025553 31 0d jeql L331
942: 903 00025555 # print_mull3_error("(Piped Entry) -BAD MULTIPLY RESULT");
943: 904 00025555 .data 1
944: 905 00000f4f * L332:
945: 906 00000f4f * 28506970656420456E7472792 .ascii "(Piped Entry) -BAD MULTIPLY RESULT\0"
946: 9202D424144204D554C544950
947: 4C5920524553554C5400
948: 907 00000f72 * .text
949: 908 00025555 dd 8f00000f4f pushl $L332
950: 909 0002555B fe 08 ef00000200 callf $8,_print_mull3_error
951: 910 00025562 # }
952: 911 00025562 # if ( halt_flg ) /* halt on error? */
953: 912 00025562 L331:
954: 913 00025562 5d effffff724 tstl _halt_flg
955: 914 00025568 31 09 jeql L333
956: 915 0002556A # mull3_halt( 1 );
957: 916 0002556A dd 01 pushl $1
958: 917 0002556C fe 08 ef000002f5 callf $8,_mull3_halt
959: 918 00025573 # if ( loop_on_err ) {
960: 919 00025573 L333:
961: 920 00025573 5d effffff713 tstl _loop_on_err
962: 921 00025579 31 0d jeql L334
963: 922 0002557B # force_loop = TRUE; /* set the force loop flag */
964: 923 0002557B 0d 01 effffff70a movl $1,_force_loop
965: 924 00025582 # asm("jmp _mull3_5_lp1"); /* and loop */
966: 925 00025582 71 effffffec4 jmp _mull3_5_lp1
967: 926 00025588 # } /* end of loop-on-error */
968: 927 00025588 # } /* end of multiply error */
969: 928 00025588 L334:
970: 929 00025588 # }
971: 930 00025588 L330:
972: 931 00025588 L317:
973: 932 00025588 6d effffff6fe incl _index
974: 933 0002558E 13 fe51 jbr L319
975: 934 00025591 L318:
976: 935 00025591 # } /* end of subtest 5 */
977: 936 00025591 40 ret#2
978: 937 00025592 .set L313,0x0
979: 938 00025592 L315:
980: 939 00025592 13 fe3a jbr L316
981: 940 00025595 .data
982: 941 00000d38 * .text
983: 942 00025595 00 .align 1
984: 943 00025596 .globl _mull3_6
985: 944 00025596 _mull3_6:
986: 945 00025596 0000 .word L335
987: 946 00025598 #
988: 947 00025598 #
989: 948 00025598 #
990: 949 00025598 # /************************************************************************
991: 950 00025598 # *
992: 951 00025598 # * SUBTEST 6 - Pipelined Exit test
993: 952 00025598 # *
994: 953 00025598 # ************************************************************************/
995: 954 00025598 # mull3_6()
996: 955 00025598 # {
997: 956 00025598 13 01c3 jbr L337
998: 957 0002559B L338:
999: 958 0002559B # force_loop = FALSE;
1000: 959 0002559B 4d effffff6eb clrl _force_loop
1001: 960 000255A1 # subtest = 6;
1002: 961 000255A1 0d 06 effffff6e4 movl $6,_subtest
1003: 962 000255A8 # for( index = 0; index < max_mull_1_index; index++ ) {
1004: 963 000255A8 4d effffff6de clrl _index
1005: 964 000255AE L341:
1006: 965 000255AE 1d effffff6d8 effffff6d3 cmpl _index,_max_mull_1_index
1007: 966 000255B9 91 03 13 019f jgeq L340
1008: 967 000255BE # sgl_value_1 = mull_1_data[index].op_1; /* get operand 1 */
1009: 968 000255BE 5c 0c effffff6c7 50 mull3 $12,_index,r0
1010: 969 000255C6 0d e000000000 effffff6bb movl _mull_1_data(r0),_sgl_value_1
1011: 970 000255D1 # sgl_value_2 = mull_1_data[index].op_2; /* get operand 2 */
1012: 971 000255D1 5c 0c effffff6b4 50 mull3 $12,_index,r0
1013: 972 000255D9 0d e000000004 effffff6a8 movl _mull_1_data+4(r0),_sgl_value_2
1014: 973 000255E4 # sgl_value_4 = mull_1_data[index].exp; /* get expected results */
1015: 974 000255E4 5c 0c effffff6a1 50 mull3 $12,_index,r0
1016: 975 000255EC 0d e000000008 effffff695 movl _mull_1_data+8(r0),_sgl_value_4
1017: 976 000255F7 # sgl_ld_acc = 0x40800000; /* floating "1.0" */
1018: 977 000255F7 0d 8f40800000 effffff68a movl $1082130432,_sgl_ld_acc
1019: 978 00025602 # sgl_value_10 = 0x12345678; /* set acc data pattern */
1020: 979 00025602 0d 8f12345678 effffff67f movl $305419896,_sgl_value_10
1021: 980 0002560D # sgl_expected = sgl_value_10; /* final Acc expected */
1022: 981 0002560D 0d effffff679 effffff674 movl _sgl_value_10,_sgl_expected
1023: 982 00025618 # /*
1024: 983 00025618 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1025: 984 00025618 # */
1026: 985 00025618 # asm("_mull3_6_lp1:");
1027: 986 00025618 _mull3_6_lp1:
1028: 987 00025618 # asm("ldf _sgl_ld_acc"); /* load the acc */
1029: 988 00025618 06 effffff66e ldf _sgl_ld_acc
1030: 989 0002561E # asm("mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3");
1031: 990 0002561E 5c effffff668 effffff663 mull3 _sgl_value_1,_sgl_value_2,_sgl_value_3
1032: effffff65e
1033: 991 0002562E # asm("mulf _sgl_value_10"); /* do a floating multiply */
1034: 992 0002562E e6 effffff658 mulf _sgl_value_10
1035: 993 00025634 # asm("stf _sgl_st_acc"); /* save the acc */
1036: 994 00025634 26 effffff652 stf _sgl_st_acc
1037: 995 0002563A # if( force_loop )
1038: 996 0002563A 5d effffff64c tstl _force_loop
1039: 997 00025640 31 02 jeql L342
1040: 998 00025642 # asm("brb _mull3_6_lp1");;
1041: 999 00025642 11 d4 brb _mull3_6_lp1
1042: 1000 00025644 L342:
1043: 1001 00025644 # if( sgl_expected != sgl_st_acc ) { /* COMPARE the values */
1044: 1002 00025644 1d effffff642 effffff63d cmpl _sgl_expected,_sgl_st_acc
1045: 1003 0002564F 21 03 13 00b2 jeql L343
1046: 1004 00025654 # errcnt++; /* bump the error count */
1047: 1005 00025654 6d effffff632 incl _errcnt
1048: 1006 0002565A # if ( prt_error ) {
1049: 1007 0002565A 5d effffff62c tstl _prt_error
1050: 1008 00025660 31 7e jeql L344
1051: 1009 00025662 # print_mull3_error("(Piped Exit) -BAD FINAL ACC");
1052: 1010 00025662 .data 1
1053: 1011 00000f72 * L345:
1054: 1012 00000f72 * 2850697065642045786974292 .ascii "(Piped Exit) -BAD FINAL ACC\0"
1055: 02D4241442046494E414C2041
1056: 434300
1057: 1013 00000f8e * .text
1058: 1014 00025662 dd 8f00000f72 pushl $L345
1059: 1015 00025668 fe 08 ef000000f3 callf $8,_print_mull3_error
1060: 1016 0002566F # writes("initial Acc = ");
1061: 1017 0002566F .data 1
1062: 1018 00000f8e * L346:
1063: 1019 00000f8e * 696E697469616C20416363203 .ascii "initial Acc = \0"
1064: D2000
1065: 1020 00000f9d * .text
1066: 1021 0002566F dd 8f00000f8e pushl $L346
1067: 1022 00025675 fe 08 effffff610 callf $8,_writes
1068: 1023 0002567C # write32h( sgl_ld_acc );
1069: 1024 0002567C dd effffff60a pushl _sgl_ld_acc
1070: 1025 00025682 fe 08 effffff603 callf $8,_write32h
1071: 1026 00025689 # writes(", final Acc = ");
1072: 1027 00025689 .data 1
1073: 1028 00000f9d * L347:
1074: 1029 00000f9d * 2C202020202066696E616C204 .ascii ", final Acc = \0"
1075: 16363203D2000
1076: 1030 00000fb0 * .text
1077: 1031 00025689 dd 8f00000f9d pushl $L347
1078: 1032 0002568F fe 08 effffff5f6 callf $8,_writes
1079: 1033 00025696 # write32h( sgl_st_acc );
1080: 1034 00025696 dd effffff5f0 pushl _sgl_st_acc
1081: 1035 0002569C fe 08 effffff5e9 callf $8,_write32h
1082: 1036 000256A3 # writes("\nFPP operand = ");
1083: 1037 000256A3 .data 1
1084: 1038 00000fb0 * L348:
1085: 1039 00000fb0 * 0A465050206F706572616E642 .ascii "\12FPP operand = \0"
1086: 03D2000
1087: 1040 00000fc0 * .text
1088: 1041 000256A3 dd 8f00000fb0 pushl $L348
1089: 1042 000256A9 fe 08 effffff5dc callf $8,_writes
1090: 1043 000256B0 # write32h( sgl_value_10 );
1091: 1044 000256B0 dd effffff5d6 pushl _sgl_value_10
1092: 1045 000256B6 fe 08 effffff5cf callf $8,_write32h
1093: 1046 000256BD # writes(", expected Acc = ");
1094: 1047 000256BD .data 1
1095: 1048 00000fc0 * L349:
1096: 1049 00000fc0 * 2C20206578706563746564204 .ascii ", expected Acc = \0"
1097: 16363203D2000
1098: 1050 00000fd3 * .text
1099: 1051 000256BD dd 8f00000fc0 pushl $L349
1100: 1052 000256C3 fe 08 effffff5c2 callf $8,_writes
1101: 1053 000256CA # write32h( sgl_expected );
1102: 1054 000256CA dd effffff5bc pushl _sgl_expected
1103: 1055 000256D0 fe 08 effffff5b5 callf $8,_write32h
1104: 1056 000256D7 # writec('\n');
1105: 1057 000256D7 dd 0a pushl $10
1106: 1058 000256D9 fe 08 effffff5ac callf $8,_writec
1107: 1059 000256E0 # }
1108: 1060 000256E0 # if ( halt_flg ) /* halt on error? */
1109: 1061 000256E0 L344:
1110: 1062 000256E0 5d effffff5a6 tstl _halt_flg
1111: 1063 000256E6 31 09 jeql L350
1112: 1064 000256E8 # mull3_halt( 5 );
1113: 1065 000256E8 dd 05 pushl $5
1114: 1066 000256EA fe 08 ef00000177 callf $8,_mull3_halt
1115: 1067 000256F1 # if ( loop_on_err ) {
1116: 1068 000256F1 L350:
1117: 1069 000256F1 5d effffff595 tstl _loop_on_err
1118: 1070 000256F7 31 0d jeql L351
1119: 1071 000256F9 # force_loop = TRUE; /* set the force loop flag */
1120: 1072 000256F9 0d 01 effffff58c movl $1,_force_loop
1121: 1073 00025700 # asm("jmp _mull3_6_lp1"); /* and loop */
1122: 1074 00025700 71 efffffff12 jmp _mull3_6_lp1
1123: 1075 00025706 # } /* end of loop-on-error */
1124: 1076 00025706 # } /* end of acc corr error */
1125: 1077 00025706 L351:
1126: 1078 00025706 # if( sgl_value_4 != sgl_value_3 ) /* COMPARE the values */
1127: 1079 00025706 L343:
1128: 1080 00025706 1d effffff580 effffff57b cmpl _sgl_value_4,_sgl_value_3
1129: 1081 00025711 31 41 jeql L352
1130: 1082 00025713 # {
1131: 1083 00025713 # errcnt++; /* bump the error count */
1132: 1084 00025713 6d effffff573 incl _errcnt
1133: 1085 00025719 # if ( prt_error ) {
1134: 1086 00025719 5d effffff56d tstl _prt_error
1135: 1087 0002571F 31 0d jeql L353
1136: 1088 00025721 # print_mull3_error("(Piped Exit) -BAD MULTIPLY RESULT");
1137: 1089 00025721 .data 1
1138: 1090 00000fd3 * L354:
1139: 1091 00000fd3 * 2850697065642045786974292 .ascii "(Piped Exit) -BAD MULTIPLY RESULT\0"
1140: 02D424144204D554C5449504C
1141: 5920524553554C5400
1142: 1092 00000ff5 * .text
1143: 1093 00025721 dd 8f00000fd3 pushl $L354
1144: 1094 00025727 fe 08 ef00000034 callf $8,_print_mull3_error
1145: 1095 0002572E # }
1146: 1096 0002572E # if ( halt_flg ) /* halt on error? */
1147: 1097 0002572E L353:
1148: 1098 0002572E 5d effffff558 tstl _halt_flg
1149: 1099 00025734 31 09 jeql L355
1150: 1100 00025736 # mull3_halt( 1 );
1151: 1101 00025736 dd 01 pushl $1
1152: 1102 00025738 fe 08 ef00000129 callf $8,_mull3_halt
1153: 1103 0002573F # if ( loop_on_err ) {
1154: 1104 0002573F L355:
1155: 1105 0002573F 5d effffff547 tstl _loop_on_err
1156: 1106 00025745 31 0d jeql L356
1157: 1107 00025747 # force_loop = TRUE; /* set the force loop flag */
1158: 1108 00025747 0d 01 effffff53e movl $1,_force_loop
1159: 1109 0002574E # asm("jmp _mull3_6_lp1"); /* and loop */
1160: 1110 0002574E 71 effffffec4 jmp _mull3_6_lp1
1161: 1111 00025754 # } /* end of loop-on-error */
1162: 1112 00025754 # } /* end of multiply error */
1163: 1113 00025754 L356:
1164: 1114 00025754 # }
1165: 1115 00025754 L352:
1166: 1116 00025754 L339:
1167: 1117 00025754 6d effffff532 incl _index
1168: 1118 0002575A 13 fe51 jbr L341
1169: 1119 0002575D L340:
1170: 1120 0002575D # } /* end of subtest 6 */
1171: 1121 0002575D 40 ret#2
1172: 1122 0002575E .set L335,0x0
1173: 1123 0002575E L337:
1174: 1124 0002575E 13 fe3a jbr L338
1175: 1125 00025761 .data
1176: 1126 00000d38 * .text
1177: 1127 00025761 00 .align 1
1178: 1128 00025762 .globl _print_mull3_error
1179: 1129 00025762 _print_mull3_error:
1180: 1130 00025762 0000 .word L357
1181: 1131 00025764 #
1182: 1132 00025764 #
1183: 1133 00025764 #
1184: 1134 00025764 # /*****************************************************************************
1185: 1135 00025764 # *
1186: 1136 00025764 # * Print an error message of the form:
1187: 1137 00025764 # *
1188: 1138 00025764 # * cycle: xx MULL3 test xx, subtest xx <"your message here">
1189: 1139 00025764 # * operand 1 = xxxxxxxx, result = xxxxxxxx, data index = xx
1190: 1140 00025764 # * operand 2 = xxxxxxxx, expected = xxxxxxxx
1191: 1141 00025764 # *
1192: 1142 00025764 # *****************************************************************************/
1193: 1143 00025764 # print_mull3_error(msg)
1194: 1144 00025764 # char *msg; /* addressing mode msg */
1195: 1145 00025764 # {
1196: 1146 00025764 13 00fe jbr L359
1197: 1147 00025767 L360:
1198: 1148 00025767 # writes(" \n"); /* start a new print line */
1199: 1149 00025767 .data 1
1200: 1150 00000ff5 * L361:
1201: 1151 00000ff5 * 200A00 .ascii " \12\0"
1202: 1152 00000ff8 * .text
1203: 1153 00025767 dd 8f00000ff5 pushl $L361
1204: 1154 0002576D fe 08 effffff518 callf $8,_writes
1205: 1155 00025774 # writes("cycle: ");
1206: 1156 00025774 .data 1
1207: 1157 00000ff8 * L362:
1208: 1158 00000ff8 * 6379636C653A2000 .ascii "cycle: \0"
1209: 1159 00001000 * .text
1210: 1160 00025774 dd 8f00000ff8 pushl $L362
1211: 1161 0002577A fe 08 effffff50b callf $8,_writes
1212: 1162 00025781 # writed( cycle );
1213: 1163 00025781 dd effffff505 pushl _cycle
1214: 1164 00025787 fe 08 effffff4fe callf $8,_writed
1215: 1165 0002578E # writes(" MULL3 test ");
1216: 1166 0002578E .data 1
1217: 1167 00001000 * L364:
1218: 1168 00001000 * 20204D554C4C3320746573742 .ascii " MULL3 test \0"
1219: 000
1220: 1169 0000100e * .text
1221: 1170 0002578E dd 8f00001000 pushl $L364
1222: 1171 00025794 fe 08 effffff4f1 callf $8,_writes
1223: 1172 0002579B # writed( test_no );
1224: 1173 0002579B dd effffff4eb pushl _test_no
1225: 1174 000257A1 fe 08 effffff4e4 callf $8,_writed
1226: 1175 000257A8 # writes(", subtest ");
1227: 1176 000257A8 .data 1
1228: 1177 0000100e * L365:
1229: 1178 0000100e * 2C20737562746573742000 .ascii ", subtest \0"
1230: 1179 00001019 * .text
1231: 1180 000257A8 dd 8f0000100e pushl $L365
1232: 1181 000257AE fe 08 effffff4d7 callf $8,_writes
1233: 1182 000257B5 # writed( subtest );
1234: 1183 000257B5 dd effffff4d1 pushl _subtest
1235: 1184 000257BB fe 08 effffff4ca callf $8,_writed
1236: 1185 000257C2 # writes(" ");
1237: 1186 000257C2 .data 1
1238: 1187 00001019 * L366:
1239: 1188 00001019 * 202000 .ascii " \0"
1240: 1189 0000101c * .text
1241: 1190 000257C2 dd 8f00001019 pushl $L366
1242: 1191 000257C8 fe 08 effffff4bd callf $8,_writes
1243: 1192 000257CF # writes( msg );
1244: 1193 000257CF dd ad04 pushl 4(fp)
1245: 1194 000257D2 fe 08 effffff4b3 callf $8,_writes
1246: 1195 000257D9 # writes("\n operand 1 = ");
1247: 1196 000257D9 .data 1
1248: 1197 0000101c * L367:
1249: 1198 0000101c * 0A20206F706572616E6420312 .ascii "\12 operand 1 = \0"
1250: 03D2000
1251: 1199 0000102c * .text
1252: 1200 000257D9 dd 8f0000101c pushl $L367
1253: 1201 000257DF fe 08 effffff4a6 callf $8,_writes
1254: 1202 000257E6 # write32h( sgl_value_1 );
1255: 1203 000257E6 dd effffff4a0 pushl _sgl_value_1
1256: 1204 000257EC fe 08 effffff499 callf $8,_write32h
1257: 1205 000257F3 # writes(", result = ");
1258: 1206 000257F3 .data 1
1259: 1207 0000102c * L368:
1260: 1208 0000102c * 2C20202020202020207265737 .ascii ", result = \0"
1261: 56C74203D2000
1262: 1209 0000103f * .text
1263: 1210 000257F3 dd 8f0000102c pushl $L368
1264: 1211 000257F9 fe 08 effffff48c callf $8,_writes
1265: 1212 00025800 # write32h( sgl_value_3 );
1266: 1213 00025800 dd effffff486 pushl _sgl_value_3
1267: 1214 00025806 fe 08 effffff47f callf $8,_write32h
1268: 1215 0002580D # writes(", data index = ");
1269: 1216 0002580D .data 1
1270: 1217 0000103f * L369:
1271: 1218 0000103f * 2C2020206461746120696E646 .ascii ", data index = \0"
1272: 578203D2000
1273: 1219 00001051 * .text
1274: 1220 0002580D dd 8f0000103f pushl $L369
1275: 1221 00025813 fe 08 effffff472 callf $8,_writes
1276: 1222 0002581A # writed( index );
1277: 1223 0002581A dd effffff46c pushl _index
1278: 1224 00025820 fe 08 effffff465 callf $8,_writed
1279: 1225 00025827 # writes("\n operand 2 = ");
1280: 1226 00025827 .data 1
1281: 1227 00001051 * L370:
1282: 1228 00001051 * 0A20206F706572616E6420322 .ascii "\12 operand 2 = \0"
1283: 03D2000
1284: 1229 00001061 * .text
1285: 1230 00025827 dd 8f00001051 pushl $L370
1286: 1231 0002582D fe 08 effffff458 callf $8,_writes
1287: 1232 00025834 # write32h( sgl_value_2 );
1288: 1233 00025834 dd effffff452 pushl _sgl_value_2
1289: 1234 0002583A fe 08 effffff44b callf $8,_write32h
1290: 1235 00025841 # writes(", expected = ");
1291: 1236 00025841 .data 1
1292: 1237 00001061 * L371:
1293: 1238 00001061 * 2C20202020202065787065637 .ascii ", expected = \0"
1294: 46564203D2000
1295: 1239 00001074 * .text
1296: 1240 00025841 dd 8f00001061 pushl $L371
1297: 1241 00025847 fe 08 effffff43e callf $8,_writes
1298: 1242 0002584E # write32h( sgl_value_4 );
1299: 1243 0002584E dd effffff438 pushl _sgl_value_4
1300: 1244 00025854 fe 08 effffff431 callf $8,_write32h
1301: 1245 0002585B # writec('\n');
1302: 1246 0002585B dd 0a pushl $10
1303: 1247 0002585D fe 08 effffff428 callf $8,_writec
1304: 1248 00025864 # }
1305: 1249 00025864 40 ret#2
1306: 1250 00025865 .set L357,0x0
1307: 1251 00025865 L359:
1308: 1252 00025865 13 feff jbr L360
1309: 1253 00025868 .data
1310: 1254 00000d38 * .text
1311: 1255 00025868 .align 1
1312: 1256 00025868 .globl _mull3_halt
1313: 1257 00025868 _mull3_halt:
1314: 1258 00025868 0000 .word L372
1315: 1259 0002586A #
1316: 1260 0002586A #
1317: 1261 0002586A #
1318: 1262 0002586A # /***************************************************************************
1319: 1263 0002586A # *
1320: 1264 0002586A # * HALT ON AN ERROR
1321: 1265 0002586A # *
1322: 1266 0002586A # ***************************************************************************/
1323: 1267 0002586A # mull3_halt( code )
1324: 1268 0002586A # int code; /* error code to use */
1325: 1269 0002586A # {
1326: 1270 0002586A 13 0152 jbr L374
1327: 1271 0002586D L375:
1328: 1272 0002586D # sgl_dummy1 = code; /* save the error code */
1329: 1273 0002586D 0d ad04 effffff417 movl 4(fp),_sgl_dummy1
1330: 1274 00025875 # asm("movl _test_no,r0"); /* r0 = test number */
1331: 1275 00025875 0d effffff411 50 movl _test_no,r0
1332: 1276 0002587C # asm("movl _subtest,r1"); /* r1 = subtest number */
1333: 1277 0002587C 0d effffff40a 51 movl _subtest,r1
1334: 1278 00025883 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1335: 1279 00025883 0d effffff403 52 movl _sgl_dummy1,r2
1336: 1280 0002588A # asm("movl _cycle,r3"); /* r3 = cycle count */
1337: 1281 0002588A 0d effffff3fc 53 movl _cycle,r3
1338: 1282 00025891 # asm("movl _sgl_value_1,r4"); /* r4 = operand 1 */
1339: 1283 00025891 0d effffff3f5 54 movl _sgl_value_1,r4
1340: 1284 00025898 # asm("movl _sgl_value_2,r5"); /* r5 = operand 2 */
1341: 1285 00025898 0d effffff3ee 55 movl _sgl_value_2,r5
1342: 1286 0002589F # asm("movl _sgl_value_3,r6"); /* r6 = MULL3's result */
1343: 1287 0002589F 0d effffff3e7 56 movl _sgl_value_3,r6
1344: 1288 000258A6 # if( code == 1 ) {
1345: 1289 000258A6 1d ad04 01 cmpl 4(fp),$1
1346: 1290 000258AA 21 11 jneq L376
1347: 1291 000258AC # asm("movl _sgl_value_4,r7"); /* r7 = expected result */
1348: 1292 000258AC 0d effffff3da 57 movl _sgl_value_4,r7
1349: 1293 000258B3 # asm("movl _index,r8");; /* r8 = data index */
1350: 1294 000258B3 0d effffff3d3 58 movl _index,r8
1351: 1295 000258BA # }
1352: 1296 000258BA # else if( code == 2 ) { /* corrupted register */
1353: 1297 000258BA 13 0100 jbr L377
1354: 1298 000258BD L376:
1355: 1299 000258BD 1d ad04 02 cmpl 4(fp),$2
1356: 1300 000258C1 21 3e jneq L378
1357: 1301 000258C3 # sgl_dummy1 = store_regs[index2]; /* get the actual reg data */
1358: 1302 000258C3 0d effffff3c3 50 movl _index2,r0
1359: 1303 000258CA 0d 40effffff3bb movl _store_regs[r0],_sgl_dummy1
1360: effffff3b6
1361: 1304 000258D6 # sgl_dummy2 = load_regs[index2]; /* get the data expected */
1362: 1305 000258D6 0d effffff3b0 50 movl _index2,r0
1363: 1306 000258DD 0d 40effffff3a8 movl _load_regs[r0],_sgl_dummy2
1364: effffff3a3
1365: 1307 000258E9 # asm("movl _index2,r7"); /* r7 = register number */
1366: 1308 000258E9 0d effffff39d 57 movl _index2,r7
1367: 1309 000258F0 # asm("movl _sgl_dummy1,r8"); /* r8 = final reg value */
1368: 1310 000258F0 0d effffff396 58 movl _sgl_dummy1,r8
1369: 1311 000258F7 # asm("movl _sgl_dummy2,r9"); /* r9 = expected value */
1370: 1312 000258F7 0d effffff38f 59 movl _sgl_dummy2,r9
1371: 1313 000258FE # }
1372: 1314 000258FE # else if( code == 3 ) { /* corrupted PSL */
1373: 1315 000258FE 13 00bc jbr L379
1374: 1316 00025901 L378:
1375: 1317 00025901 1d ad04 03 cmpl 4(fp),$3
1376: 1318 00025905 21 18 jneq L380
1377: 1319 00025907 # asm("movl _init_psl,r7"); /* r7 = initial PSL */
1378: 1320 00025907 0d effffff37f 57 movl _init_psl,r7
1379: 1321 0002590E # asm("movl _psl_val,r8"); /* r8 = final PSL */
1380: 1322 0002590E 0d effffff378 58 movl _psl_val,r8
1381: 1323 00025915 # asm("movl _exp_psl,r9"); /* r9 = expected PSL */
1382: 1324 00025915 0d effffff371 59 movl _exp_psl,r9
1383: 1325 0002591C # }
1384: 1326 0002591C # else if( code == 4 ) { /* corrupted Acc */
1385: 1327 0002591C 13 009e jbr L381
1386: 1328 0002591F L380:
1387: 1329 0002591F 1d ad04 04 cmpl 4(fp),$4
1388: 1330 00025923 21 6f jneq L382
1389: 1331 00025925 # if( subtest == 1 ) { /* single precision */
1390: 1332 00025925 1d effffff361 01 cmpl _subtest,$1
1391: 1333 0002592C 21 33 jneq L383
1392: 1334 0002592E # dbl_ld_acc.m = sgl_ld_acc;
1393: 1335 0002592E 0d effffff358 effffff353 movl _sgl_ld_acc,_dbl_ld_acc
1394: 1336 00025939 # dbl_ld_acc.l = 0;
1395: 1337 00025939 4d effffff351 clrl _dbl_ld_acc+4
1396: 1338 0002593F # dbl_st_acc.m = sgl_st_acc;
1397: 1339 0002593F 0d effffff347 effffff342 movl _sgl_st_acc,_dbl_st_acc
1398: 1340 0002594A # dbl_st_acc.l = 0;
1399: 1341 0002594A 4d effffff340 clrl _dbl_st_acc+4
1400: 1342 00025950 # dbl_expected.m = sgl_expected;
1401: 1343 00025950 0d effffff336 effffff331 movl _sgl_expected,_dbl_expected
1402: 1344 0002595B # dbl_expected.l = 0;
1403: 1345 0002595B 4d effffff32f clrl _dbl_expected+4
1404: 1346 00025961 # };
1405: 1347 00025961 L383:
1406: 1348 00025961 # asm("movl _index,r7"); /* r7 = data index */
1407: 1349 00025961 0d effffff325 57 movl _index,r7
1408: 1350 00025968 # asm("movl _dbl_ld_acc,r8"); /* r8 = MS initial Acc. */
1409: 1351 00025968 0d effffff31e 58 movl _dbl_ld_acc,r8
1410: 1352 0002596F # asm("movl _dbl_ld_acc+4,r9"); /* r9 = LS initial Acc. */
1411: 1353 0002596F 0d effffff31b 59 movl _dbl_ld_acc+4,r9
1412: 1354 00025976 # asm("movl _dbl_st_acc,r10"); /* r10 = MS final Acc. */
1413: 1355 00025976 0d effffff310 5a movl _dbl_st_acc,r10
1414: 1356 0002597D # asm("movl _dbl_st_acc+4,r11"); /* r11 = LS final Acc. */
1415: 1357 0002597D 0d effffff30d 5b movl _dbl_st_acc+4,r11
1416: 1358 00025984 # asm("movl _dbl_expected,r12"); /* r12 = MS expected Acc. */
1417: 1359 00025984 0d effffff302 5c movl _dbl_expected,r12
1418: 1360 0002598B # asm("movl _dbl_expected+4,r13"); /* r13 = LS expected Acc. */
1419: 1361 0002598B 0d effffff2ff 5d movl _dbl_expected+4,r13
1420: 1362 00025992 # }
1421: 1363 00025992 # else if( code == 5 ) { /* bad final Acc */
1422: 1364 00025992 11 29 jbr L384
1423: 1365 00025994 L382:
1424: 1366 00025994 1d ad04 05 cmpl 4(fp),$5
1425: 1367 00025998 21 23 jneq L385
1426: 1368 0002599A # asm("movl _index,r7"); /* r7 = data index */
1427: 1369 0002599A 0d effffff2ec 57 movl _index,r7
1428: 1370 000259A1 # asm("movl _sgl_ld_acc,r8"); /* r8 = initial Acc. */
1429: 1371 000259A1 0d effffff2e5 58 movl _sgl_ld_acc,r8
1430: 1372 000259A8 # asm("movl _sgl_value_10,r9"); /* r9 = fpp operand */
1431: 1373 000259A8 0d effffff2de 59 movl _sgl_value_10,r9
1432: 1374 000259AF # asm("movl _sgl_st_acc,r10"); /* r10 = final Acc. */
1433: 1375 000259AF 0d effffff2d7 5a movl _sgl_st_acc,r10
1434: 1376 000259B6 # asm("movl _sgl_expected,r11"); /* r11 = expected Acc. */
1435: 1377 000259B6 0d effffff2d0 5b movl _sgl_expected,r11
1436: 1378 000259BD # };
1437: 1379 000259BD L385:
1438: 1380 000259BD L384:
1439: 1381 000259BD L381:
1440: 1382 000259BD L379:
1441: 1383 000259BD L377:
1442: 1384 000259BD # asm("halt"); /* HALT ... */
1443: 1385 000259BD 00 halt
1444: 1386 000259BE # }
1445: 1387 000259BE 40 ret#2
1446: 1388 000259BF .set L372,0x0
1447: 1389 000259BF L374:
1448: 1390 000259BF 13 feab jbr L375
1449: 1391 000259C2 .data
1450: 1391 0004A64E .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.