![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf2.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 cmpf2.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 00001458 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _cmpf2
6: 6 00000000 _cmpf2:
7: 7 00013044 0000 .word L215
8: 8 00013046 # #include "fpp_defs.h"
9: 9 00013046 #
10: 10 00013046 #
11: 11 00013046 #
12: 12 00013046 # /***************************************************************************
13: 13 00013046 # *
14: 14 00013046 # * CMPF2 -COMPARE 2 SGL OPERANDS TO EACH OTHER -IGNORE THE ACCUMULATOR
15: 15 00013046 # *
16: 16 00013046 # *****************************************************************************/
17: 17 00013046 # cmpf2()
18: 18 00013046 # {
19: 19 00013046 11 65 jbr L217
20: 20 00013048 L218:
21: 21 00013048 # asm(".globl _cmpf2_t");
22: 22 00013048 .globl _cmpf2_t
23: 23 00013048 # asm("_cmpf2_t:"); /* entry address */
24: 24 00013048 _cmpf2_t:
25: 25 00013048 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26: 26 00013048 1d effffffff6 01 cmpl _cycle,$1
27: 27 0001304F 21 15 jneq L219
28: 28 00013051 5d efffffffed tstl _prt_hdrs
29: 29 00013057 31 0d jeql L219
30: 30 00013059 # writes(" CMPF2");
31: 31 00013059 .data 1
32: 32 00001458 * L221:
33: 33 00001458 * 20434D50463200 .ascii " CMPF2\0"
34: 34 0000145f * .text
35: 35 00013059 dd 8f00001458 pushl $L221
36: 36 0001305F fe 08 efffffffde callf $8,_writes
37: 37 00013066 # cmpf2_1(); /* register / register data */
38: 38 00013066 L219:
39: 39 00013066 fe 04 ef00000043 callf $4,_cmpf2_1
40: 40 0001306D # cmpf2_2(); /* cache / cache data */
41: 41 0001306D fe 04 ef000002da callf $4,_cmpf2_2
42: 42 00013074 # cmpf2_3(); /* cache / register data */
43: 43 00013074 fe 04 ef0000056b callf $4,_cmpf2_3
44: 44 0001307B # cmpf2_4(); /* register / cache data */
45: 45 0001307B fe 04 ef000007f8 callf $4,_cmpf2_4
46: 46 00013082 # cmpf2_5(); /* acc. corruption test */
47: 47 00013082 fe 04 ef00000a8b callf $4,_cmpf2_5
48: 48 00013089 # cmpf2_6(); /* register corruption test */
49: 49 00013089 fe 04 ef00000c9c callf $4,_cmpf2_6
50: 50 00013090 # if( !no_fpp_wcs ) {
51: 51 00013090 5d efffffffae tstl _no_fpp_wcs
52: 52 00013096 21 0e jneq L228
53: 53 00013098 # cmpf2_7(); /* pipelined entry test */
54: 54 00013098 fe 04 ef00000e7d callf $4,_cmpf2_7
55: 55 0001309F # cmpf2_8(); /* pipelined exit test */
56: 56 0001309F fe 04 ef0000110c callf $4,_cmpf2_8
57: 57 000130A6 # };
58: 58 000130A6 L228:
59: 59 000130A6 # asm("jmp *return"); /* return to the test monitor */
60: 60 000130A6 71 ffffffff98 jmp *return
61: 61 000130AC # }
62: 62 000130AC 40 ret#2
63: 63 000130AD .set L215,0x0
64: 64 000130AD L217:
65: 65 000130AD 11 99 jbr L218
66: 66 000130AF .data
67: 67 00001458 * .text
68: 68 000130AF 00 .align 1
69: 69 000130B0 .globl _cmpf2_1
70: 70 000130B0 _cmpf2_1:
71: 71 000130B0 0000 .word L231
72: 72 000130B2 #
73: 73 000130B2 #
74: 74 000130B2 #
75: 75 000130B2 # /****************************************************************************
76: 76 000130B2 # *
77: 77 000130B2 # * SUBTEST 1 - CMPF2 test -register / register data
78: 78 000130B2 # *
79: 79 000130B2 # ****************************************************************************/
80: 80 000130B2 # cmpf2_1()
81: 81 000130B2 # {
82: 82 000130B2 13 0295 jbr L233
83: 83 000130B5 L234:
84: 84 000130B5 # force_loop = FALSE;
85: 85 000130B5 4d efffffff89 clrl _force_loop
86: 86 000130BB # subtest = 1;
87: 87 000130BB 0d 01 efffffff82 movl $1,_subtest
88: 88 000130C2 # index = 0;
89: 89 000130C2 4d efffffff7c clrl _index
90: 90 000130C8 # do
91: 91 000130C8 L237:
92: 92 000130C8 # {
93: 93 000130C8 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
94: 94 000130C8 5c 0c efffffff75 50 mull3 $12,_index,r0
95: 95 000130D0 0d e000000000 efffffff69 movl _cmpf_1_data(r0),_sgl_value_1
96: 96 000130DB # sgl_value_2 = cmpf_1_data[index].two;
97: 97 000130DB 5c 0c efffffff62 50 mull3 $12,_index,r0
98: 98 000130E3 0d e000000004 efffffff56 movl _cmpf_1_data+4(r0),_sgl_value_2
99: 99 000130EE # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
100: 100 000130EE 5c 0c efffffff4f 50 mull3 $12,_index,r0
101: 101 000130F6 0d e000000008 efffffff43 movl _cmpf_1_data+8(r0),_sgl_expected
102: 102 00013101 # index2 = 0; /* clear Acc. data index */
103: 103 00013101 4d efffffff3d clrl _index2
104: 104 00013107 # do
105: 105 00013107 L240:
106: 106 00013107 # {
107: 107 00013107 # sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
108: 108 00013107 0d efffffff37 50 movl _index2,r0
109: 109 0001310E 48 03 50 50 shll $3,r0,r0
110: 110 00013112 0d e000000000 efffffff27 movl _ldf_1_data(r0),_sgl_ld_acc
111: 111 0001311D 6d efffffff21 incl _index2
112: 112 00013123 # status_index = 0; /* clear the status index */
113: 113 00013123 4d efffffff1b clrl _status_index
114: 114 00013129 # do
115: 115 00013129 L243:
116: 116 00013129 # {
117: 117 00013129 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
118: 118 00013129 0d efffffff15 50 movl _status_index,r0
119: 119 00013130 0d 40efffffff0d movl _status_array[r0],_sgl_dummy1
120: efffffff08
121: 120 0001313C # /*
122: 121 0001313C # * If LOOP ON ERROR is set, this is the loop for this subtest.
123: 122 0001313C # * The force loop flag is set after the first error.
124: 123 0001313C # */
125: 124 0001313C # asm("_cmpf2_1_lp1:");
126: 125 0001313C _cmpf2_1_lp1:
127: 126 0001313C # asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
128: 127 0001313C 0d efffffff02 53 movl _sgl_ld_acc,r3
129: 128 00013143 # asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
130: 129 00013143 0d effffffefb 54 movl _sgl_value_1,r4
131: 130 0001314A # asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
132: 131 0001314A 0d effffffef4 55 movl _sgl_value_2,r5
133: 132 00013151 # asm("ldf r3"); /* load the accumulator */
134: 133 00013151 06 53 ldf r3
135: 134 00013153 # asm("tstl _sgl_dummy1"); /* generate initial status */
136: 135 00013153 5d effffffeeb tstl _sgl_dummy1
137: 136 00013159 # asm("movpsl _init_psl"); /* save the initial status */
138: 137 00013159 cd effffffee5 movpsl _init_psl
139: 138 0001315F # asm("cmpf2 r4,r5"); /* compare the operands */
140: 139 0001315F 46 54 55 cmpf2 r4,r5
141: 140 00013162 # asm("movpsl _psl_val"); /* save the final status */
142: 141 00013162 cd effffffedc movpsl _psl_val
143: 142 00013168 # asm("stf r6"); /* save the accumulator */
144: 143 00013168 26 56 stf r6
145: 144 0001316A # if( force_loop ) /* loop? */
146: 145 0001316A 5d effffffed4 tstl _force_loop
147: 146 00013170 31 02 jeql L244
148: 147 00013172 # asm("brb _cmpf2_1_lp1");; /* run the loop again */
149: 148 00013172 11 c8 brb _cmpf2_1_lp1
150: 149 00013174 L244:
151: 150 00013174 # asm("movl r6,_sgl_st_acc"); /* put the acc into cache */
152: 151 00013174 0d 56 effffffec9 movl r6,_sgl_st_acc
153: 152 0001317B # exp_psl = init_psl; /* get the initial PSL */
154: 153 0001317B 0d effffffec3 effffffebe movl _init_psl,_exp_psl
155: 154 00013186 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
156: 155 00013186 ac 88f3 effffffeb6 andl2 $-13,_exp_psl
157: 156 0001318E # if( sgl_expected == ZERO )
158: 157 0001318E 1d effffffeb0 04 cmpl _sgl_expected,$4
159: 158 00013195 21 07 jneq L245
160: 159 00013197 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
161: 160 00013197 8c 04 effffffea6 orl2 $4,_exp_psl
162: 161 0001319E # if( sgl_expected == NEGATIVE )
163: 162 0001319E L245:
164: 163 0001319E 1d effffffea0 08 cmpl _sgl_expected,$8
165: 164 000131A5 21 07 jneq L246
166: 165 000131A7 # exp_psl |= PSL_N; /* expect the NEG bit set */
167: 166 000131A7 8c 08 effffffe96 orl2 $8,_exp_psl
168: 167 000131AE # if( psl_val != exp_psl ) /* COMPARE the values */
169: 168 000131AE L246:
170: 169 000131AE 1d effffffe90 effffffe8b cmpl _psl_val,_exp_psl
171: 170 000131B9 21 03 13 0144 jeql L247
172: 171 000131BE # {
173: 172 000131BE # errcnt++; /* bump the error count */
174: 173 000131BE 6d effffffe80 incl _errcnt
175: 174 000131C4 # if ( prt_error ) {
176: 175 000131C4 5d effffffe7a tstl _prt_error
177: 176 000131CA 21 03 13 0110 jeql L248
178: 177 000131CF # writes(" \n"); /* start a new print line */
179: 178 000131CF .data 1
180: 179 0000145f * L249:
181: 180 0000145f * 200A00 .ascii " \12\0"
182: 181 00001462 * .text
183: 182 000131CF dd 8f0000145f pushl $L249
184: 183 000131D5 fe 08 effffffe68 callf $8,_writes
185: 184 000131DC # writes("cycle: ");
186: 185 000131DC .data 1
187: 186 00001462 * L250:
188: 187 00001462 * 6379636C653A2000 .ascii "cycle: \0"
189: 188 0000146a * .text
190: 189 000131DC dd 8f00001462 pushl $L250
191: 190 000131E2 fe 08 effffffe5b callf $8,_writes
192: 191 000131E9 # writed( cycle );
193: 192 000131E9 dd effffffe55 pushl _cycle
194: 193 000131EF fe 08 effffffe4e callf $8,_writed
195: 194 000131F6 # writes(" CMPF2 test ");
196: 195 000131F6 .data 1
197: 196 0000146a * L252:
198: 197 0000146a * 2020434D50463220746573742 .ascii " CMPF2 test \0"
199: 000
200: 198 00001478 * .text
201: 199 000131F6 dd 8f0000146a pushl $L252
202: 200 000131FC fe 08 effffffe41 callf $8,_writes
203: 201 00013203 # writed( test_no );
204: 202 00013203 dd effffffe3b pushl _test_no
205: 203 00013209 fe 08 effffffe34 callf $8,_writed
206: 204 00013210 # writes(", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\n");
207: 205 00013210 .data 1
208: 206 00001478 * L253:
209: 207 00001478 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\12\0"
210: 85265672E2F5265672E204461
211: 746129202D204241442046494
212: E414C2050534C0A00
213: 208 000014a6 * .text
214: 209 00013210 dd 8f00001478 pushl $L253
215: 210 00013216 fe 08 effffffe27 callf $8,_writes
216: 211 0001321D # print_cmpf2_data();
217: 212 0001321D fe 04 ef00001182 callf $4,_print_cmpf2_data
218: 213 00013224 # writes(", data index = ");
219: 214 00013224 .data 1
220: 215 000014a6 * L255:
221: 216 000014a6 * 2C20206461746120696E64657 .ascii ", data index = \0"
222: 8203D2000
223: 217 000014b7 * .text
224: 218 00013224 dd 8f000014a6 pushl $L255
225: 219 0001322A fe 08 effffffe13 callf $8,_writes
226: 220 00013231 # writed( index );
227: 221 00013231 dd effffffe0d pushl _index
228: 222 00013237 fe 08 effffffe06 callf $8,_writed
229: 223 0001323E # writec('\n');
230: 224 0001323E dd 0a pushl $10
231: 225 00013240 fe 08 effffffdfd callf $8,_writec
232: 226 00013247 # writes(" final Acc = ");
233: 227 00013247 .data 1
234: 228 000014b7 * L257:
235: 229 000014b7 * 20202066696E616C204163632 .ascii " final Acc = \0"
236: 03D2000
237: 230 000014c7 * .text
238: 231 00013247 dd 8f000014b7 pushl $L257
239: 232 0001324D fe 08 effffffdf0 callf $8,_writes
240: 233 00013254 # write32h( sgl_st_acc );
241: 234 00013254 dd effffffdea pushl _sgl_st_acc
242: 235 0001325A fe 08 effffffde3 callf $8,_write32h
243: 236 00013261 # writes(", operand 2 = ");
244: 237 00013261 .data 1
245: 238 000014c7 * L259:
246: 239 000014c7 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
247: 03D2000
248: 240 000014d7 * .text
249: 241 00013261 dd 8f000014c7 pushl $L259
250: 242 00013267 fe 08 effffffdd6 callf $8,_writes
251: 243 0001326E # write32h( sgl_value_2 );
252: 244 0001326E dd effffffdd0 pushl _sgl_value_2
253: 245 00013274 fe 08 effffffdc9 callf $8,_write32h
254: 246 0001327B # writec('\n');
255: 247 0001327B dd 0a pushl $10
256: 248 0001327D fe 08 effffffdc0 callf $8,_writec
257: 249 00013284 # writes(" initial PSL = ");
258: 250 00013284 .data 1
259: 251 000014d7 * L260:
260: 252 000014d7 * 20696E697469616C2050534C2 .ascii " initial PSL = \0"
261: 03D2000
262: 253 000014e7 * .text
263: 254 00013284 dd 8f000014d7 pushl $L260
264: 255 0001328A fe 08 effffffdb3 callf $8,_writes
265: 256 00013291 # write32h( init_psl );
266: 257 00013291 dd effffffdad pushl _init_psl
267: 258 00013297 fe 08 effffffda6 callf $8,_write32h
268: 259 0001329E # writes(", final PSL = ");
269: 260 0001329E .data 1
270: 261 000014e7 * L261:
271: 262 000014e7 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
272: 03D2000
273: 263 000014f7 * .text
274: 264 0001329E dd 8f000014e7 pushl $L261
275: 265 000132A4 fe 08 effffffd99 callf $8,_writes
276: 266 000132AB # write32h( psl_val );
277: 267 000132AB dd effffffd93 pushl _psl_val
278: 268 000132B1 fe 08 effffffd8c callf $8,_write32h
279: 269 000132B8 # writes(", expected PSL = ");
280: 270 000132B8 .data 1
281: 271 000014f7 * L262:
282: 272 000014f7 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
283: 0534C203D2000
284: 273 0000150a * .text
285: 274 000132B8 dd 8f000014f7 pushl $L262
286: 275 000132BE fe 08 effffffd7f callf $8,_writes
287: 276 000132C5 # write32h( exp_psl );
288: 277 000132C5 dd effffffd79 pushl _exp_psl
289: 278 000132CB fe 08 effffffd72 callf $8,_write32h
290: 279 000132D2 # writes(" \n");
291: 280 000132D2 .data 1
292: 281 0000150a * L263:
293: 282 0000150a * 200A00 .ascii " \12\0"
294: 283 0000150d * .text
295: 284 000132D2 dd 8f0000150a pushl $L263
296: 285 000132D8 fe 08 effffffd65 callf $8,_writes
297: 286 000132DF # }
298: 287 000132DF # if ( halt_flg )
299: 288 000132DF L248:
300: 289 000132DF 5d effffffd5f tstl _halt_flg
301: 290 000132E5 31 09 jeql L264
302: 291 000132E7 # cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
303: 292 000132E7 dd 03 pushl $3
304: 293 000132E9 fe 08 ef000010f2 callf $8,_cmpf2_er_halt
305: 294 000132F0 # if ( loop_on_err ) {
306: 295 000132F0 L264:
307: 296 000132F0 5d effffffd4e tstl _loop_on_err
308: 297 000132F6 31 0a jeql L266
309: 298 000132F8 # force_loop = TRUE; /* set the force loop flag */
310: 299 000132F8 0d 01 effffffd45 movl $1,_force_loop
311: 300 000132FF # asm("brw _cmpf2_1_lp1"); /* and loop */
312: 301 000132FF 13 fe3a brw _cmpf2_1_lp1
313: 302 00013302 # }; /* end of loop-on-error */
314: 303 00013302 L266:
315: 304 00013302 # } /* end of compare error */
316: 305 00013302 # } while( ++status_index < 3 );
317: 306 00013302 L247:
318: 307 00013302 L242:
319: 308 00013302 6d effffffd3c incl _status_index
320: 309 00013308 0d effffffd36 50 movl _status_index,r0
321: 310 0001330F 1d 50 03 cmpl r0,$3
322: 311 00013312 81 03 13 fe12 jlss L243
323: 312 00013317 L241:
324: 313 00013317 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
325: 314 00013317 L239:
326: 315 00013317 1d effffffd27 0a cmpl _index2,$10
327: 316 0001331E 81 10 jgeq L9999
328: 317 00013320 1d effffffd1e effffffd19 cmpl _index2,_max_ldf_1_index
329: 318 0001332B 81 03 13 fdd7 jlss L240
330: 319 00013330 L9999:
331: 320 00013330 L238:
332: 321 00013330 # } while( index++ < max_cmpf_1_index );
333: 322 00013330 L236:
334: 323 00013330 0d effffffd0e 50 movl _index,r0
335: 324 00013337 6d effffffd07 incl _index
336: 325 0001333D 1d 50 effffffd00 cmpl r0,_max_cmpf_1_index
337: 326 00013344 81 03 13 fd7f jlss L237
338: 327 00013349 L235:
339: 328 00013349 # } /* end of subtest 1 */
340: 329 00013349 40 ret#2
341: 330 0001334A .set L231,0x0
342: 331 0001334A L233:
343: 332 0001334A 13 fd68 jbr L234
344: 333 0001334D .data
345: 334 00001458 * .text
346: 335 0001334D 00 .align 1
347: 336 0001334E .globl _cmpf2_2
348: 337 0001334E _cmpf2_2:
349: 338 0001334E 0000 .word L267
350: 339 00013350 #
351: 340 00013350 #
352: 341 00013350 #
353: 342 00013350 # /****************************************************************************
354: 343 00013350 # *
355: 344 00013350 # * SUBTEST 2 - CMPF2 test - cache / cache data
356: 345 00013350 # *
357: 346 00013350 # ****************************************************************************/
358: 347 00013350 # cmpf2_2()
359: 348 00013350 # {
360: 349 00013350 13 0290 jbr L269
361: 350 00013353 L270:
362: 351 00013353 # force_loop = FALSE;
363: 352 00013353 4d effffffceb clrl _force_loop
364: 353 00013359 # subtest = 2;
365: 354 00013359 0d 02 effffffce4 movl $2,_subtest
366: 355 00013360 # index = 0;
367: 356 00013360 4d effffffcde clrl _index
368: 357 00013366 # do
369: 358 00013366 L273:
370: 359 00013366 # {
371: 360 00013366 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
372: 361 00013366 5c 0c effffffcd7 50 mull3 $12,_index,r0
373: 362 0001336E 0d e000000000 effffffccb movl _cmpf_1_data(r0),_sgl_value_1
374: 363 00013379 # sgl_value_2 = cmpf_1_data[index].two;
375: 364 00013379 5c 0c effffffcc4 50 mull3 $12,_index,r0
376: 365 00013381 0d e000000004 effffffcb8 movl _cmpf_1_data+4(r0),_sgl_value_2
377: 366 0001338C # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
378: 367 0001338C 5c 0c effffffcb1 50 mull3 $12,_index,r0
379: 368 00013394 0d e000000008 effffffca5 movl _cmpf_1_data+8(r0),_sgl_expected
380: 369 0001339F # index2 = 0; /* clear Acc. data index */
381: 370 0001339F 4d effffffc9f clrl _index2
382: 371 000133A5 # do
383: 372 000133A5 L276:
384: 373 000133A5 # {
385: 374 000133A5 # sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
386: 375 000133A5 0d effffffc99 50 movl _index2,r0
387: 376 000133AC 48 03 50 50 shll $3,r0,r0
388: 377 000133B0 0d e000000000 effffffc89 movl _ldf_1_data(r0),_sgl_ld_acc
389: 378 000133BB 6d effffffc83 incl _index2
390: 379 000133C1 # status_index = 0; /* clear the status index */
391: 380 000133C1 4d effffffc7d clrl _status_index
392: 381 000133C7 # do
393: 382 000133C7 L279:
394: 383 000133C7 # {
395: 384 000133C7 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
396: 385 000133C7 0d effffffc77 50 movl _status_index,r0
397: 386 000133CE 0d 40effffffc6f movl _status_array[r0],_sgl_dummy1
398: effffffc6a
399: 387 000133DA # /*
400: 388 000133DA # * If LOOP ON ERROR is set, this is the loop for this subtest.
401: 389 000133DA # * The force loop flag is set after the first error.
402: 390 000133DA # */
403: 391 000133DA # asm("_cmpf2_2_lp1:");
404: 392 000133DA _cmpf2_2_lp1:
405: 393 000133DA # asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
406: 394 000133DA 0d effffffc64 53 movl _sgl_ld_acc,r3
407: 395 000133E1 # asm("ldf _sgl_ld_acc"); /* load the accumulator */
408: 396 000133E1 06 effffffc5d ldf _sgl_ld_acc
409: 397 000133E7 # asm("tstl _sgl_dummy1"); /* generate initial status */
410: 398 000133E7 5d effffffc57 tstl _sgl_dummy1
411: 399 000133ED # asm("movpsl _init_psl"); /* save the initial status */
412: 400 000133ED cd effffffc51 movpsl _init_psl
413: 401 000133F3 # asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
414: 402 000133F3 46 effffffc4b effffffc46 cmpf2 _sgl_value_1,_sgl_value_2
415: 403 000133FE # asm("movpsl _psl_val"); /* save the final status */
416: 404 000133FE cd effffffc40 movpsl _psl_val
417: 405 00013404 # asm("stf _sgl_st_acc"); /* save the acc */
418: 406 00013404 26 effffffc3a stf _sgl_st_acc
419: 407 0001340A # if( force_loop ) /* loop? */
420: 408 0001340A 5d effffffc34 tstl _force_loop
421: 409 00013410 31 02 jeql L280
422: 410 00013412 # asm("brb _cmpf2_2_lp1");; /* run the loop again */
423: 411 00013412 11 c6 brb _cmpf2_2_lp1
424: 412 00013414 L280:
425: 413 00013414 # exp_psl = init_psl; /* get the initial PSL */
426: 414 00013414 0d effffffc2a effffffc25 movl _init_psl,_exp_psl
427: 415 0001341F # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
428: 416 0001341F ac 88f3 effffffc1d andl2 $-13,_exp_psl
429: 417 00013427 # if( sgl_expected == ZERO )
430: 418 00013427 1d effffffc17 04 cmpl _sgl_expected,$4
431: 419 0001342E 21 07 jneq L281
432: 420 00013430 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
433: 421 00013430 8c 04 effffffc0d orl2 $4,_exp_psl
434: 422 00013437 # if( sgl_expected == NEGATIVE )
435: 423 00013437 L281:
436: 424 00013437 1d effffffc07 08 cmpl _sgl_expected,$8
437: 425 0001343E 21 07 jneq L282
438: 426 00013440 # exp_psl |= PSL_N; /* expect the NEG bit set */
439: 427 00013440 8c 08 effffffbfd orl2 $8,_exp_psl
440: 428 00013447 # if( psl_val != exp_psl ) /* COMPARE the values */
441: 429 00013447 L282:
442: 430 00013447 1d effffffbf7 effffffbf2 cmpl _psl_val,_exp_psl
443: 431 00013452 21 03 13 0144 jeql L283
444: 432 00013457 # {
445: 433 00013457 # errcnt++; /* bump the error count */
446: 434 00013457 6d effffffbe7 incl _errcnt
447: 435 0001345D # if ( prt_error ) {
448: 436 0001345D 5d effffffbe1 tstl _prt_error
449: 437 00013463 21 03 13 0110 jeql L284
450: 438 00013468 # writes(" \n"); /* start a new print line */
451: 439 00013468 .data 1
452: 440 0000150d * L285:
453: 441 0000150d * 200A00 .ascii " \12\0"
454: 442 00001510 * .text
455: 443 00013468 dd 8f0000150d pushl $L285
456: 444 0001346E fe 08 effffffbcf callf $8,_writes
457: 445 00013475 # writes("cycle: ");
458: 446 00013475 .data 1
459: 447 00001510 * L286:
460: 448 00001510 * 6379636C653A2000 .ascii "cycle: \0"
461: 449 00001518 * .text
462: 450 00013475 dd 8f00001510 pushl $L286
463: 451 0001347B fe 08 effffffbc2 callf $8,_writes
464: 452 00013482 # writed( cycle );
465: 453 00013482 dd effffffbbc pushl _cycle
466: 454 00013488 fe 08 effffffbb5 callf $8,_writed
467: 455 0001348F # writes(" CMPF2 test ");
468: 456 0001348F .data 1
469: 457 00001518 * L287:
470: 458 00001518 * 2020434D50463220746573742 .ascii " CMPF2 test \0"
471: 000
472: 459 00001526 * .text
473: 460 0001348F dd 8f00001518 pushl $L287
474: 461 00013495 fe 08 effffffba8 callf $8,_writes
475: 462 0001349C # writed( test_no );
476: 463 0001349C dd effffffba2 pushl _test_no
477: 464 000134A2 fe 08 effffffb9b callf $8,_writed
478: 465 000134A9 # writes(", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\n");
479: 466 000134A9 .data 1
480: 467 00001526 * L288:
481: 468 00001526 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\12\0"
482: 843616368652F436163686520
483: 4461746129202D20424144204
484: 6494E414C2050534C0A00
485: 469 00001556 * .text
486: 470 000134A9 dd 8f00001526 pushl $L288
487: 471 000134AF fe 08 effffffb8e callf $8,_writes
488: 472 000134B6 # print_cmpf2_data();
489: 473 000134B6 fe 04 ef00000ee9 callf $4,_print_cmpf2_data
490: 474 000134BD # writes(", data index = ");
491: 475 000134BD .data 1
492: 476 00001556 * L289:
493: 477 00001556 * 2C20206461746120696E64657 .ascii ", data index = \0"
494: 8203D2000
495: 478 00001567 * .text
496: 479 000134BD dd 8f00001556 pushl $L289
497: 480 000134C3 fe 08 effffffb7a callf $8,_writes
498: 481 000134CA # writed( index );
499: 482 000134CA dd effffffb74 pushl _index
500: 483 000134D0 fe 08 effffffb6d callf $8,_writed
501: 484 000134D7 # writec('\n');
502: 485 000134D7 dd 0a pushl $10
503: 486 000134D9 fe 08 effffffb64 callf $8,_writec
504: 487 000134E0 # writes(" final Acc = ");
505: 488 000134E0 .data 1
506: 489 00001567 * L290:
507: 490 00001567 * 20202066696E616C204163632 .ascii " final Acc = \0"
508: 03D2000
509: 491 00001577 * .text
510: 492 000134E0 dd 8f00001567 pushl $L290
511: 493 000134E6 fe 08 effffffb57 callf $8,_writes
512: 494 000134ED # write32h( sgl_st_acc );
513: 495 000134ED dd effffffb51 pushl _sgl_st_acc
514: 496 000134F3 fe 08 effffffb4a callf $8,_write32h
515: 497 000134FA # writes(", operand 2 = ");
516: 498 000134FA .data 1
517: 499 00001577 * L291:
518: 500 00001577 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
519: 03D2000
520: 501 00001587 * .text
521: 502 000134FA dd 8f00001577 pushl $L291
522: 503 00013500 fe 08 effffffb3d callf $8,_writes
523: 504 00013507 # write32h( sgl_value_2 );
524: 505 00013507 dd effffffb37 pushl _sgl_value_2
525: 506 0001350D fe 08 effffffb30 callf $8,_write32h
526: 507 00013514 # writec('\n');
527: 508 00013514 dd 0a pushl $10
528: 509 00013516 fe 08 effffffb27 callf $8,_writec
529: 510 0001351D # writes(" initial PSL = ");
530: 511 0001351D .data 1
531: 512 00001587 * L292:
532: 513 00001587 * 20696E697469616C2050534C2 .ascii " initial PSL = \0"
533: 03D2000
534: 514 00001597 * .text
535: 515 0001351D dd 8f00001587 pushl $L292
536: 516 00013523 fe 08 effffffb1a callf $8,_writes
537: 517 0001352A # write32h( init_psl );
538: 518 0001352A dd effffffb14 pushl _init_psl
539: 519 00013530 fe 08 effffffb0d callf $8,_write32h
540: 520 00013537 # writes(", final PSL = ");
541: 521 00013537 .data 1
542: 522 00001597 * L293:
543: 523 00001597 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
544: 03D2000
545: 524 000015a7 * .text
546: 525 00013537 dd 8f00001597 pushl $L293
547: 526 0001353D fe 08 effffffb00 callf $8,_writes
548: 527 00013544 # write32h( psl_val );
549: 528 00013544 dd effffffafa pushl _psl_val
550: 529 0001354A fe 08 effffffaf3 callf $8,_write32h
551: 530 00013551 # writes(", expected PSL = ");
552: 531 00013551 .data 1
553: 532 000015a7 * L294:
554: 533 000015a7 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
555: 0534C203D2000
556: 534 000015ba * .text
557: 535 00013551 dd 8f000015a7 pushl $L294
558: 536 00013557 fe 08 effffffae6 callf $8,_writes
559: 537 0001355E # write32h( exp_psl );
560: 538 0001355E dd effffffae0 pushl _exp_psl
561: 539 00013564 fe 08 effffffad9 callf $8,_write32h
562: 540 0001356B # writes(" \n");
563: 541 0001356B .data 1
564: 542 000015ba * L295:
565: 543 000015ba * 200A00 .ascii " \12\0"
566: 544 000015bd * .text
567: 545 0001356B dd 8f000015ba pushl $L295
568: 546 00013571 fe 08 effffffacc callf $8,_writes
569: 547 00013578 # }
570: 548 00013578 # if ( halt_flg )
571: 549 00013578 L284:
572: 550 00013578 5d effffffac6 tstl _halt_flg
573: 551 0001357E 31 09 jeql L296
574: 552 00013580 # cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
575: 553 00013580 dd 03 pushl $3
576: 554 00013582 fe 08 ef00000e59 callf $8,_cmpf2_er_halt
577: 555 00013589 # if ( loop_on_err )
578: 556 00013589 L296:
579: 557 00013589 5d effffffab5 tstl _loop_on_err
580: 558 0001358F 31 0a jeql L297
581: 559 00013591 # {
582: 560 00013591 # force_loop = TRUE; /* set the force loop flag */
583: 561 00013591 0d 01 effffffaac movl $1,_force_loop
584: 562 00013598 # asm("brw _cmpf2_2_lp1"); /* and loop */
585: 563 00013598 13 fe3f brw _cmpf2_2_lp1
586: 564 0001359B # }; /* end of loop-on-error */
587: 565 0001359B L297:
588: 566 0001359B # } /* end of compare error */
589: 567 0001359B # } while( ++status_index < 3 );
590: 568 0001359B L283:
591: 569 0001359B L278:
592: 570 0001359B 6d effffffaa3 incl _status_index
593: 571 000135A1 0d effffffa9d 50 movl _status_index,r0
594: 572 000135A8 1d 50 03 cmpl r0,$3
595: 573 000135AB 81 03 13 fe17 jlss L279
596: 574 000135B0 L277:
597: 575 000135B0 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
598: 576 000135B0 L275:
599: 577 000135B0 1d effffffa8e 0a cmpl _index2,$10
600: 578 000135B7 81 10 jgeq L9998
601: 579 000135B9 1d effffffa85 effffffa80 cmpl _index2,_max_ldf_1_index
602: 580 000135C4 81 03 13 fddc jlss L276
603: 581 000135C9 L9998:
604: 582 000135C9 L274:
605: 583 000135C9 # } while( index++ < max_cmpf_1_index );
606: 584 000135C9 L272:
607: 585 000135C9 0d effffffa75 50 movl _index,r0
608: 586 000135D0 6d effffffa6e incl _index
609: 587 000135D6 1d 50 effffffa67 cmpl r0,_max_cmpf_1_index
610: 588 000135DD 81 03 13 fd84 jlss L273
611: 589 000135E2 L271:
612: 590 000135E2 # } /* end of subtest 2 */
613: 591 000135E2 40 ret#2
614: 592 000135E3 .set L267,0x0
615: 593 000135E3 L269:
616: 594 000135E3 13 fd6d jbr L270
617: 595 000135E6 .data
618: 596 00001458 * .text
619: 597 000135E6 .align 1
620: 598 000135E6 .globl _cmpf2_3
621: 599 000135E6 _cmpf2_3:
622: 600 000135E6 0000 .word L298
623: 601 000135E8 #
624: 602 000135E8 #
625: 603 000135E8 #
626: 604 000135E8 # /****************************************************************************
627: 605 000135E8 # *
628: 606 000135E8 # * SUBTEST 3 - CMPF2 test - cache / register data
629: 607 000135E8 # *
630: 608 000135E8 # ****************************************************************************/
631: 609 000135E8 # cmpf2_3()
632: 610 000135E8 # {
633: 611 000135E8 13 028c jbr L300
634: 612 000135EB L301:
635: 613 000135EB # force_loop = FALSE;
636: 614 000135EB 4d effffffa53 clrl _force_loop
637: 615 000135F1 # subtest = 3;
638: 616 000135F1 0d 03 effffffa4c movl $3,_subtest
639: 617 000135F8 # index = 0;
640: 618 000135F8 4d effffffa46 clrl _index
641: 619 000135FE # do
642: 620 000135FE L304:
643: 621 000135FE # {
644: 622 000135FE # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
645: 623 000135FE 5c 0c effffffa3f 50 mull3 $12,_index,r0
646: 624 00013606 0d e000000000 effffffa33 movl _cmpf_1_data(r0),_sgl_value_1
647: 625 00013611 # sgl_value_2 = cmpf_1_data[index].two;
648: 626 00013611 5c 0c effffffa2c 50 mull3 $12,_index,r0
649: 627 00013619 0d e000000004 effffffa20 movl _cmpf_1_data+4(r0),_sgl_value_2
650: 628 00013624 # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
651: 629 00013624 5c 0c effffffa19 50 mull3 $12,_index,r0
652: 630 0001362C 0d e000000008 effffffa0d movl _cmpf_1_data+8(r0),_sgl_expected
653: 631 00013637 # index2 = 0; /* clear Acc. data index */
654: 632 00013637 4d effffffa07 clrl _index2
655: 633 0001363D # do
656: 634 0001363D L307:
657: 635 0001363D # {
658: 636 0001363D # sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
659: 637 0001363D 0d effffffa01 50 movl _index2,r0
660: 638 00013644 48 03 50 50 shll $3,r0,r0
661: 639 00013648 0d e000000000 effffff9f1 movl _ldf_1_data(r0),_sgl_ld_acc
662: 640 00013653 6d effffff9eb incl _index2
663: 641 00013659 # status_index = 0; /* clear the status index */
664: 642 00013659 4d effffff9e5 clrl _status_index
665: 643 0001365F # do
666: 644 0001365F L310:
667: 645 0001365F # {
668: 646 0001365F # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
669: 647 0001365F 0d effffff9df 50 movl _status_index,r0
670: 648 00013666 0d 40effffff9d7 movl _status_array[r0],_sgl_dummy1
671: effffff9d2
672: 649 00013672 # /*
673: 650 00013672 # * If LOOP ON ERROR is set, this is the loop for this subtest.
674: 651 00013672 # * The force loop flag is set after the first error.
675: 652 00013672 # */
676: 653 00013672 # asm("_cmpf2_3_lp1:");
677: 654 00013672 _cmpf2_3_lp1:
678: 655 00013672 # asm("ldf _sgl_ld_acc"); /* load the accmulator */
679: 656 00013672 06 effffff9cc ldf _sgl_ld_acc
680: 657 00013678 # asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
681: 658 00013678 0d effffff9c6 55 movl _sgl_value_2,r5
682: 659 0001367F # asm("tstl _sgl_dummy1"); /* generate initial status */
683: 660 0001367F 5d effffff9bf tstl _sgl_dummy1
684: 661 00013685 # asm("movpsl _init_psl"); /* save the initial status */
685: 662 00013685 cd effffff9b9 movpsl _init_psl
686: 663 0001368B # asm("cmpf2 _sgl_value_1,r5"); /* compare the data */
687: 664 0001368B 46 effffff9b3 55 cmpf2 _sgl_value_1,r5
688: 665 00013692 # asm("movpsl _psl_val"); /* save the final status */
689: 666 00013692 cd effffff9ac movpsl _psl_val
690: 667 00013698 # asm("stf _sgl_st_acc"); /* save the acc */
691: 668 00013698 26 effffff9a6 stf _sgl_st_acc
692: 669 0001369E # if( force_loop ) /* loop? */
693: 670 0001369E 5d effffff9a0 tstl _force_loop
694: 671 000136A4 31 02 jeql L311
695: 672 000136A6 # asm("brb _cmpf2_3_lp1");; /* run the loop again */
696: 673 000136A6 11 ca brb _cmpf2_3_lp1
697: 674 000136A8 L311:
698: 675 000136A8 # exp_psl = init_psl; /* get the initial PSL */
699: 676 000136A8 0d effffff996 effffff991 movl _init_psl,_exp_psl
700: 677 000136B3 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
701: 678 000136B3 ac 88f3 effffff989 andl2 $-13,_exp_psl
702: 679 000136BB # if( sgl_expected == ZERO )
703: 680 000136BB 1d effffff983 04 cmpl _sgl_expected,$4
704: 681 000136C2 21 07 jneq L312
705: 682 000136C4 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
706: 683 000136C4 8c 04 effffff979 orl2 $4,_exp_psl
707: 684 000136CB # if( sgl_expected == NEGATIVE )
708: 685 000136CB L312:
709: 686 000136CB 1d effffff973 08 cmpl _sgl_expected,$8
710: 687 000136D2 21 07 jneq L313
711: 688 000136D4 # exp_psl |= PSL_N; /* expect the NEG bit set */
712: 689 000136D4 8c 08 effffff969 orl2 $8,_exp_psl
713: 690 000136DB # if( psl_val != exp_psl ) /* COMPARE the values */
714: 691 000136DB L313:
715: 692 000136DB 1d effffff963 effffff95e cmpl _psl_val,_exp_psl
716: 693 000136E6 21 03 13 0144 jeql L314
717: 694 000136EB # {
718: 695 000136EB # errcnt++; /* bump the error count */
719: 696 000136EB 6d effffff953 incl _errcnt
720: 697 000136F1 # if ( prt_error ) {
721: 698 000136F1 5d effffff94d tstl _prt_error
722: 699 000136F7 21 03 13 0110 jeql L315
723: 700 000136FC # writes(" \n"); /* start a new print line */
724: 701 000136FC .data 1
725: 702 000015bd * L316:
726: 703 000015bd * 200A00 .ascii " \12\0"
727: 704 000015c0 * .text
728: 705 000136FC dd 8f000015bd pushl $L316
729: 706 00013702 fe 08 effffff93b callf $8,_writes
730: 707 00013709 # writes("cycle: ");
731: 708 00013709 .data 1
732: 709 000015c0 * L317:
733: 710 000015c0 * 6379636C653A2000 .ascii "cycle: \0"
734: 711 000015c8 * .text
735: 712 00013709 dd 8f000015c0 pushl $L317
736: 713 0001370F fe 08 effffff92e callf $8,_writes
737: 714 00013716 # writed( cycle );
738: 715 00013716 dd effffff928 pushl _cycle
739: 716 0001371C fe 08 effffff921 callf $8,_writed
740: 717 00013723 # writes(" CMPF2 test ");
741: 718 00013723 .data 1
742: 719 000015c8 * L318:
743: 720 000015c8 * 2020434D50463220746573742 .ascii " CMPF2 test \0"
744: 000
745: 721 000015d6 * .text
746: 722 00013723 dd 8f000015c8 pushl $L318
747: 723 00013729 fe 08 effffff914 callf $8,_writes
748: 724 00013730 # writed( test_no );
749: 725 00013730 dd effffff90e pushl _test_no
750: 726 00013736 fe 08 effffff907 callf $8,_writed
751: 727 0001373D # writes(", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\n");
752: 728 0001373D .data 1
753: 729 000015d6 * L319:
754: 730 000015d6 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\12\0"
755: 843616368652F5265672E2044
756: 61746129202D2042414420464
757: 94E414C2050534C0A00
758: 731 00001605 * .text
759: 732 0001373D dd 8f000015d6 pushl $L319
760: 733 00013743 fe 08 effffff8fa callf $8,_writes
761: 734 0001374A # print_cmpf2_data();
762: 735 0001374A fe 04 ef00000c55 callf $4,_print_cmpf2_data
763: 736 00013751 # writes(", data index = ");
764: 737 00013751 .data 1
765: 738 00001605 * L320:
766: 739 00001605 * 2C20206461746120696E64657 .ascii ", data index = \0"
767: 8203D2000
768: 740 00001616 * .text
769: 741 00013751 dd 8f00001605 pushl $L320
770: 742 00013757 fe 08 effffff8e6 callf $8,_writes
771: 743 0001375E # writed( index );
772: 744 0001375E dd effffff8e0 pushl _index
773: 745 00013764 fe 08 effffff8d9 callf $8,_writed
774: 746 0001376B # writec('\n');
775: 747 0001376B dd 0a pushl $10
776: 748 0001376D fe 08 effffff8d0 callf $8,_writec
777: 749 00013774 # writes(" final Acc = ");
778: 750 00013774 .data 1
779: 751 00001616 * L321:
780: 752 00001616 * 20202066696E616C204163632 .ascii " final Acc = \0"
781: 03D2000
782: 753 00001626 * .text
783: 754 00013774 dd 8f00001616 pushl $L321
784: 755 0001377A fe 08 effffff8c3 callf $8,_writes
785: 756 00013781 # write32h( sgl_st_acc );
786: 757 00013781 dd effffff8bd pushl _sgl_st_acc
787: 758 00013787 fe 08 effffff8b6 callf $8,_write32h
788: 759 0001378E # writes(", operand 2 = ");
789: 760 0001378E .data 1
790: 761 00001626 * L322:
791: 762 00001626 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
792: 03D2000
793: 763 00001636 * .text
794: 764 0001378E dd 8f00001626 pushl $L322
795: 765 00013794 fe 08 effffff8a9 callf $8,_writes
796: 766 0001379B # write32h( sgl_value_2 );
797: 767 0001379B dd effffff8a3 pushl _sgl_value_2
798: 768 000137A1 fe 08 effffff89c callf $8,_write32h
799: 769 000137A8 # writec('\n');
800: 770 000137A8 dd 0a pushl $10
801: 771 000137AA fe 08 effffff893 callf $8,_writec
802: 772 000137B1 # writes(" initial PSL = ");
803: 773 000137B1 .data 1
804: 774 00001636 * L323:
805: 775 00001636 * 20696E697469616C2050534C2 .ascii " initial PSL = \0"
806: 03D2000
807: 776 00001646 * .text
808: 777 000137B1 dd 8f00001636 pushl $L323
809: 778 000137B7 fe 08 effffff886 callf $8,_writes
810: 779 000137BE # write32h( init_psl );
811: 780 000137BE dd effffff880 pushl _init_psl
812: 781 000137C4 fe 08 effffff879 callf $8,_write32h
813: 782 000137CB # writes(", final PSL = ");
814: 783 000137CB .data 1
815: 784 00001646 * L324:
816: 785 00001646 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
817: 03D2000
818: 786 00001656 * .text
819: 787 000137CB dd 8f00001646 pushl $L324
820: 788 000137D1 fe 08 effffff86c callf $8,_writes
821: 789 000137D8 # write32h( psl_val );
822: 790 000137D8 dd effffff866 pushl _psl_val
823: 791 000137DE fe 08 effffff85f callf $8,_write32h
824: 792 000137E5 # writes(", expected PSL = ");
825: 793 000137E5 .data 1
826: 794 00001656 * L325:
827: 795 00001656 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
828: 0534C203D2000
829: 796 00001669 * .text
830: 797 000137E5 dd 8f00001656 pushl $L325
831: 798 000137EB fe 08 effffff852 callf $8,_writes
832: 799 000137F2 # write32h( exp_psl );
833: 800 000137F2 dd effffff84c pushl _exp_psl
834: 801 000137F8 fe 08 effffff845 callf $8,_write32h
835: 802 000137FF # writes(" \n");
836: 803 000137FF .data 1
837: 804 00001669 * L326:
838: 805 00001669 * 200A00 .ascii " \12\0"
839: 806 0000166c * .text
840: 807 000137FF dd 8f00001669 pushl $L326
841: 808 00013805 fe 08 effffff838 callf $8,_writes
842: 809 0001380C # }
843: 810 0001380C # if ( halt_flg )
844: 811 0001380C L315:
845: 812 0001380C 5d effffff832 tstl _halt_flg
846: 813 00013812 31 09 jeql L327
847: 814 00013814 # cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
848: 815 00013814 dd 03 pushl $3
849: 816 00013816 fe 08 ef00000bc5 callf $8,_cmpf2_er_halt
850: 817 0001381D # if ( loop_on_err )
851: 818 0001381D L327:
852: 819 0001381D 5d effffff821 tstl _loop_on_err
853: 820 00013823 31 0a jeql L328
854: 821 00013825 # {
855: 822 00013825 # force_loop = TRUE; /* set the force loop flag */
856: 823 00013825 0d 01 effffff818 movl $1,_force_loop
857: 824 0001382C # asm("brw _cmpf2_3_lp1"); /* and loop */
858: 825 0001382C 13 fe43 brw _cmpf2_3_lp1
859: 826 0001382F # }; /* end of loop-on-error */
860: 827 0001382F L328:
861: 828 0001382F # } /* end of compare error */
862: 829 0001382F # } while( ++status_index < 3 );
863: 830 0001382F L314:
864: 831 0001382F L309:
865: 832 0001382F 6d effffff80f incl _status_index
866: 833 00013835 0d effffff809 50 movl _status_index,r0
867: 834 0001383C 1d 50 03 cmpl r0,$3
868: 835 0001383F 81 03 13 fe1b jlss L310
869: 836 00013844 L308:
870: 837 00013844 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
871: 838 00013844 L306:
872: 839 00013844 1d effffff7fa 0a cmpl _index2,$10
873: 840 0001384B 81 10 jgeq L9997
874: 841 0001384D 1d effffff7f1 effffff7ec cmpl _index2,_max_ldf_1_index
875: 842 00013858 81 03 13 fde0 jlss L307
876: 843 0001385D L9997:
877: 844 0001385D L305:
878: 845 0001385D # } while( index++ < max_cmpf_1_index );
879: 846 0001385D L303:
880: 847 0001385D 0d effffff7e1 50 movl _index,r0
881: 848 00013864 6d effffff7da incl _index
882: 849 0001386A 1d 50 effffff7d3 cmpl r0,_max_cmpf_1_index
883: 850 00013871 81 03 13 fd88 jlss L304
884: 851 00013876 L302:
885: 852 00013876 # } /* end of subtest 3 */
886: 853 00013876 40 ret#2
887: 854 00013877 .set L298,0x0
888: 855 00013877 L300:
889: 856 00013877 13 fd71 jbr L301
890: 857 0001387A .data
891: 858 00001458 * .text
892: 859 0001387A .align 1
893: 860 0001387A .globl _cmpf2_4
894: 861 0001387A _cmpf2_4:
895: 862 0001387A 0000 .word L329
896: 863 0001387C #
897: 864 0001387C #
898: 865 0001387C #
899: 866 0001387C # /****************************************************************************
900: 867 0001387C # *
901: 868 0001387C # * SUBTEST 4 - CMPF2 test - register / cache data
902: 869 0001387C # *
903: 870 0001387C # ****************************************************************************/
904: 871 0001387C # cmpf2_4()
905: 872 0001387C # {
906: 873 0001387C 13 0292 jbr L331
907: 874 0001387F L332:
908: 875 0001387F # force_loop = FALSE;
909: 876 0001387F 4d effffff7bf clrl _force_loop
910: 877 00013885 # subtest = 4;
911: 878 00013885 0d 04 effffff7b8 movl $4,_subtest
912: 879 0001388C # index = 0;
913: 880 0001388C 4d effffff7b2 clrl _index
914: 881 00013892 # do
915: 882 00013892 L335:
916: 883 00013892 # {
917: 884 00013892 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
918: 885 00013892 5c 0c effffff7ab 50 mull3 $12,_index,r0
919: 886 0001389A 0d e000000000 effffff79f movl _cmpf_1_data(r0),_sgl_value_1
920: 887 000138A5 # sgl_value_2 = cmpf_1_data[index].two;
921: 888 000138A5 5c 0c effffff798 50 mull3 $12,_index,r0
922: 889 000138AD 0d e000000004 effffff78c movl _cmpf_1_data+4(r0),_sgl_value_2
923: 890 000138B8 # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
924: 891 000138B8 5c 0c effffff785 50 mull3 $12,_index,r0
925: 892 000138C0 0d e000000008 effffff779 movl _cmpf_1_data+8(r0),_sgl_expected
926: 893 000138CB # index2 = 0; /* clear Acc. data index */
927: 894 000138CB 4d effffff773 clrl _index2
928: 895 000138D1 # do
929: 896 000138D1 L338:
930: 897 000138D1 # {
931: 898 000138D1 # sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
932: 899 000138D1 0d effffff76d 50 movl _index2,r0
933: 900 000138D8 48 03 50 50 shll $3,r0,r0
934: 901 000138DC 0d e000000000 effffff75d movl _ldf_1_data(r0),_sgl_ld_acc
935: 902 000138E7 6d effffff757 incl _index2
936: 903 000138ED # status_index = 0; /* clear the status index */
937: 904 000138ED 4d effffff751 clrl _status_index
938: 905 000138F3 # do
939: 906 000138F3 L341:
940: 907 000138F3 # {
941: 908 000138F3 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
942: 909 000138F3 0d effffff74b 50 movl _status_index,r0
943: 910 000138FA 0d 40effffff743 movl _status_array[r0],_sgl_dummy1
944: effffff73e
945: 911 00013906 # /*
946: 912 00013906 # * If LOOP ON ERROR is set, this is the loop for this subtest.
947: 913 00013906 # * The force loop flag is set after the first error.
948: 914 00013906 # */
949: 915 00013906 # asm("_cmpf2_4_lp1:");
950: 916 00013906 _cmpf2_4_lp1:
951: 917 00013906 # asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
952: 918 00013906 0d effffff738 53 movl _sgl_ld_acc,r3
953: 919 0001390D # asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
954: 920 0001390D 0d effffff731 54 movl _sgl_value_1,r4
955: 921 00013914 # asm("ldf r3"); /* load the accumulator */
956: 922 00013914 06 53 ldf r3
957: 923 00013916 # asm("tstl _sgl_dummy1"); /* generate initial status */
958: 924 00013916 5d effffff728 tstl _sgl_dummy1
959: 925 0001391C # asm("movpsl _init_psl"); /* save the initial status */
960: 926 0001391C cd effffff722 movpsl _init_psl
961: 927 00013922 # asm("cmpf2 r4,_sgl_value_2"); /* compare the data */
962: 928 00013922 46 54 effffff71b cmpf2 r4,_sgl_value_2
963: 929 00013929 # asm("movpsl _psl_val"); /* save the final status */
964: 930 00013929 cd effffff715 movpsl _psl_val
965: 931 0001392F # asm("stf _sgl_st_acc"); /* save the acc */
966: 932 0001392F 26 effffff70f stf _sgl_st_acc
967: 933 00013935 # if( force_loop ) /* loop? */
968: 934 00013935 5d effffff709 tstl _force_loop
969: 935 0001393B 31 02 jeql L342
970: 936 0001393D # asm("brb _cmpf2_4_lp1");; /* run the loop again */
971: 937 0001393D 11 c7 brb _cmpf2_4_lp1
972: 938 0001393F L342:
973: 939 0001393F # exp_psl = init_psl; /* get the initial PSL */
974: 940 0001393F 0d effffff6ff effffff6fa movl _init_psl,_exp_psl
975: 941 0001394A # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
976: 942 0001394A ac 88f3 effffff6f2 andl2 $-13,_exp_psl
977: 943 00013952 # if( sgl_expected == ZERO )
978: 944 00013952 1d effffff6ec 04 cmpl _sgl_expected,$4
979: 945 00013959 21 07 jneq L343
980: 946 0001395B # exp_psl |= PSL_Z; /* expect the ZERO bit set */
981: 947 0001395B 8c 04 effffff6e2 orl2 $4,_exp_psl
982: 948 00013962 # if( sgl_expected == NEGATIVE )
983: 949 00013962 L343:
984: 950 00013962 1d effffff6dc 08 cmpl _sgl_expected,$8
985: 951 00013969 21 07 jneq L344
986: 952 0001396B # exp_psl |= PSL_N; /* expect the NEG bit set */
987: 953 0001396B 8c 08 effffff6d2 orl2 $8,_exp_psl
988: 954 00013972 # if( psl_val != exp_psl ) /* COMPARE the values */
989: 955 00013972 L344:
990: 956 00013972 1d effffff6cc effffff6c7 cmpl _psl_val,_exp_psl
991: 957 0001397D 21 03 13 0147 jeql L345
992: 958 00013982 # {
993: 959 00013982 # errcnt++; /* bump the error count */
994: 960 00013982 6d effffff6bc incl _errcnt
995: 961 00013988 # if ( prt_error ) {
996: 962 00013988 5d effffff6b6 tstl _prt_error
997: 963 0001398E 21 03 13 0110 jeql L346
998: 964 00013993 # writes(" \n"); /* start a new print line */
999: 965 00013993 .data 1
1000: 966 0000166c * L347:
1001: 967 0000166c * 200A00 .ascii " \12\0"
1002: 968 0000166f * .text
1003: 969 00013993 dd 8f0000166c pushl $L347
1004: 970 00013999 fe 08 effffff6a4 callf $8,_writes
1005: 971 000139A0 # writes("cycle: ");
1006: 972 000139A0 .data 1
1007: 973 0000166f * L348:
1008: 974 0000166f * 6379636C653A2000 .ascii "cycle: \0"
1009: 975 00001677 * .text
1010: 976 000139A0 dd 8f0000166f pushl $L348
1011: 977 000139A6 fe 08 effffff697 callf $8,_writes
1012: 978 000139AD # writed( cycle );
1013: 979 000139AD dd effffff691 pushl _cycle
1014: 980 000139B3 fe 08 effffff68a callf $8,_writed
1015: 981 000139BA # writes(" CMPF2 test ");
1016: 982 000139BA .data 1
1017: 983 00001677 * L349:
1018: 984 00001677 * 2020434D50463220746573742 .ascii " CMPF2 test \0"
1019: 000
1020: 985 00001685 * .text
1021: 986 000139BA dd 8f00001677 pushl $L349
1022: 987 000139C0 fe 08 effffff67d callf $8,_writes
1023: 988 000139C7 # writed( test_no );
1024: 989 000139C7 dd effffff677 pushl _test_no
1025: 990 000139CD fe 08 effffff670 callf $8,_writed
1026: 991 000139D4 # writes(", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\n");
1027: 992 000139D4 .data 1
1028: 993 00001685 * L350:
1029: 994 00001685 * 2C20737562746573742034202 .ascii ", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\12\0"
1030: 85265672E2F43616368652044
1031: 61746129202D2042414420464
1032: 94E414C2050534C0A00
1033: 995 000016b4 * .text
1034: 996 000139D4 dd 8f00001685 pushl $L350
1035: 997 000139DA fe 08 effffff663 callf $8,_writes
1036: 998 000139E1 # print_cmpf2_data();
1037: 999 000139E1 fe 04 ef000009be callf $4,_print_cmpf2_data
1038: 1000 000139E8 # writes(", data index = ");
1039: 1001 000139E8 .data 1
1040: 1002 000016b4 * L351:
1041: 1003 000016b4 * 2C20206461746120696E64657 .ascii ", data index = \0"
1042: 8203D2000
1043: 1004 000016c5 * .text
1044: 1005 000139E8 dd 8f000016b4 pushl $L351
1045: 1006 000139EE fe 08 effffff64f callf $8,_writes
1046: 1007 000139F5 # writed( index );
1047: 1008 000139F5 dd effffff649 pushl _index
1048: 1009 000139FB fe 08 effffff642 callf $8,_writed
1049: 1010 00013A02 # writec('\n');
1050: 1011 00013A02 dd 0a pushl $10
1051: 1012 00013A04 fe 08 effffff639 callf $8,_writec
1052: 1013 00013A0B # writes(" final Acc = ");
1053: 1014 00013A0B .data 1
1054: 1015 000016c5 * L352:
1055: 1016 000016c5 * 20202066696E616C204163632 .ascii " final Acc = \0"
1056: 03D2000
1057: 1017 000016d5 * .text
1058: 1018 00013A0B dd 8f000016c5 pushl $L352
1059: 1019 00013A11 fe 08 effffff62c callf $8,_writes
1060: 1020 00013A18 # write32h( sgl_st_acc );
1061: 1021 00013A18 dd effffff626 pushl _sgl_st_acc
1062: 1022 00013A1E fe 08 effffff61f callf $8,_write32h
1063: 1023 00013A25 # writes(", operand 2 = ");
1064: 1024 00013A25 .data 1
1065: 1025 000016d5 * L353:
1066: 1026 000016d5 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
1067: 03D2000
1068: 1027 000016e5 * .text
1069: 1028 00013A25 dd 8f000016d5 pushl $L353
1070: 1029 00013A2B fe 08 effffff612 callf $8,_writes
1071: 1030 00013A32 # write32h( sgl_value_2 );
1072: 1031 00013A32 dd effffff60c pushl _sgl_value_2
1073: 1032 00013A38 fe 08 effffff605 callf $8,_write32h
1074: 1033 00013A3F # writec('\n');
1075: 1034 00013A3F dd 0a pushl $10
1076: 1035 00013A41 fe 08 effffff5fc callf $8,_writec
1077: 1036 00013A48 # writes(" initial PSL = ");
1078: 1037 00013A48 .data 1
1079: 1038 000016e5 * L354:
1080: 1039 000016e5 * 20696E697469616C2050534C2 .ascii " initial PSL = \0"
1081: 03D2000
1082: 1040 000016f5 * .text
1083: 1041 00013A48 dd 8f000016e5 pushl $L354
1084: 1042 00013A4E fe 08 effffff5ef callf $8,_writes
1085: 1043 00013A55 # write32h( init_psl );
1086: 1044 00013A55 dd effffff5e9 pushl _init_psl
1087: 1045 00013A5B fe 08 effffff5e2 callf $8,_write32h
1088: 1046 00013A62 # writes(", final PSL = ");
1089: 1047 00013A62 .data 1
1090: 1048 000016f5 * L355:
1091: 1049 000016f5 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
1092: 03D2000
1093: 1050 00001705 * .text
1094: 1051 00013A62 dd 8f000016f5 pushl $L355
1095: 1052 00013A68 fe 08 effffff5d5 callf $8,_writes
1096: 1053 00013A6F # write32h( psl_val );
1097: 1054 00013A6F dd effffff5cf pushl _psl_val
1098: 1055 00013A75 fe 08 effffff5c8 callf $8,_write32h
1099: 1056 00013A7C # writes(", expected PSL = ");
1100: 1057 00013A7C .data 1
1101: 1058 00001705 * L356:
1102: 1059 00001705 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
1103: 0534C203D2000
1104: 1060 00001718 * .text
1105: 1061 00013A7C dd 8f00001705 pushl $L356
1106: 1062 00013A82 fe 08 effffff5bb callf $8,_writes
1107: 1063 00013A89 # write32h( exp_psl );
1108: 1064 00013A89 dd effffff5b5 pushl _exp_psl
1109: 1065 00013A8F fe 08 effffff5ae callf $8,_write32h
1110: 1066 00013A96 # writes(" \n");
1111: 1067 00013A96 .data 1
1112: 1068 00001718 * L357:
1113: 1069 00001718 * 200A00 .ascii " \12\0"
1114: 1070 0000171b * .text
1115: 1071 00013A96 dd 8f00001718 pushl $L357
1116: 1072 00013A9C fe 08 effffff5a1 callf $8,_writes
1117: 1073 00013AA3 # }
1118: 1074 00013AA3 # if ( halt_flg )
1119: 1075 00013AA3 L346:
1120: 1076 00013AA3 5d effffff59b tstl _halt_flg
1121: 1077 00013AA9 31 09 jeql L358
1122: 1078 00013AAB # cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
1123: 1079 00013AAB dd 03 pushl $3
1124: 1080 00013AAD fe 08 ef0000092e callf $8,_cmpf2_er_halt
1125: 1081 00013AB4 # if ( loop_on_err )
1126: 1082 00013AB4 L358:
1127: 1083 00013AB4 5d effffff58a tstl _loop_on_err
1128: 1084 00013ABA 31 0d jeql L359
1129: 1085 00013ABC # {
1130: 1086 00013ABC # force_loop = TRUE; /* set the force loop flag */
1131: 1087 00013ABC 0d 01 effffff581 movl $1,_force_loop
1132: 1088 00013AC3 # asm("jmp _cmpf2_4_lp1"); /* and loop */
1133: 1089 00013AC3 71 effffffe3d jmp _cmpf2_4_lp1
1134: 1090 00013AC9 # } /* end of loop-on-error */
1135: 1091 00013AC9 # } /* end of compare error */
1136: 1092 00013AC9 L359:
1137: 1093 00013AC9 # } while( ++status_index < 3 );
1138: 1094 00013AC9 L345:
1139: 1095 00013AC9 L340:
1140: 1096 00013AC9 6d effffff575 incl _status_index
1141: 1097 00013ACF 0d effffff56f 50 movl _status_index,r0
1142: 1098 00013AD6 1d 50 03 cmpl r0,$3
1143: 1099 00013AD9 81 03 13 fe15 jlss L341
1144: 1100 00013ADE L339:
1145: 1101 00013ADE # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
1146: 1102 00013ADE L337:
1147: 1103 00013ADE 1d effffff560 0a cmpl _index2,$10
1148: 1104 00013AE5 81 10 jgeq L9996
1149: 1105 00013AE7 1d effffff557 effffff552 cmpl _index2,_max_ldf_1_index
1150: 1106 00013AF2 81 03 13 fdda jlss L338
1151: 1107 00013AF7 L9996:
1152: 1108 00013AF7 L336:
1153: 1109 00013AF7 # } while( index++ < max_cmpf_1_index );
1154: 1110 00013AF7 L334:
1155: 1111 00013AF7 0d effffff547 50 movl _index,r0
1156: 1112 00013AFE 6d effffff540 incl _index
1157: 1113 00013B04 1d 50 effffff539 cmpl r0,_max_cmpf_1_index
1158: 1114 00013B0B 81 03 13 fd82 jlss L335
1159: 1115 00013B10 L333:
1160: 1116 00013B10 # } /* end of subtest 4 */
1161: 1117 00013B10 40 ret#2
1162: 1118 00013B11 .set L329,0x0
1163: 1119 00013B11 L331:
1164: 1120 00013B11 13 fd6b jbr L332
1165: 1121 00013B14 .data
1166: 1122 00001458 * .text
1167: 1123 00013B14 .align 1
1168: 1124 00013B14 .globl _cmpf2_5
1169: 1125 00013B14 _cmpf2_5:
1170: 1126 00013B14 0000 .word L360
1171: 1127 00013B16 #
1172: 1128 00013B16 #
1173: 1129 00013B16 #
1174: 1130 00013B16 # /************************************************************************
1175: 1131 00013B16 # *
1176: 1132 00013B16 # * SUBTEST 5 - Check for register corruption
1177: 1133 00013B16 # *
1178: 1134 00013B16 # ************************************************************************/
1179: 1135 00013B16 # cmpf2_5()
1180: 1136 00013B16 # {
1181: 1137 00013B16 13 0210 jbr L362
1182: 1138 00013B19 L363:
1183: 1139 00013B19 # force_loop = FALSE; /* clear force_loop flg */
1184: 1140 00013B19 4d effffff525 clrl _force_loop
1185: 1141 00013B1F # subtest = 5;
1186: 1142 00013B1F 0d 05 effffff51e movl $5,_subtest
1187: 1143 00013B26 # fill_reg_buf( load_regs ); /* get pattern for regs */
1188: 1144 00013B26 dd 8f00000000 pushl $_load_regs
1189: 1145 00013B2C fe 08 effffff511 callf $8,_fill_reg_buf
1190: 1146 00013B33 # index = 0;
1191: 1147 00013B33 4d effffff50b clrl _index
1192: 1148 00013B39 # do
1193: 1149 00013B39 L367:
1194: 1150 00013B39 # {
1195: 1151 00013B39 # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
1196: 1152 00013B39 5c 0c effffff504 50 mull3 $12,_index,r0
1197: 1153 00013B41 0d e000000000 effffff4f8 movl _cmpf_1_data(r0),_sgl_value_1
1198: 1154 00013B4C # sgl_value_2 = cmpf_1_data[index].two; /* data to compare */
1199: 1155 00013B4C 5c 0c effffff4f1 50 mull3 $12,_index,r0
1200: 1156 00013B54 0d e000000004 effffff4e5 movl _cmpf_1_data+4(r0),_sgl_value_2
1201: 1157 00013B5F # /*
1202: 1158 00013B5F # * If LOOP ON ERROR is set, this is the loop for this subtest.
1203: 1159 00013B5F # * The force loop flag is set after the first error.
1204: 1160 00013B5F # */
1205: 1161 00013B5F # asm("_cmpf2_5_lp1:");
1206: 1162 00013B5F _cmpf2_5_lp1:
1207: 1163 00013B5F # asm("ldf $0x40800000"); /* LOAD the accumulator */
1208: 1164 00013B5F 06 8f40800000 ldf $0x40800000
1209: 1165 00013B65 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
1210: 1166 00013B65 ab 891fff effffff4d6 loadr $0x1fff,_load_regs
1211: 1167 00013B6E # asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
1212: 1168 00013B6E 46 effffff4d0 effffff4cb cmpf2 _sgl_value_1,_sgl_value_2
1213: 1169 00013B79 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
1214: 1170 00013B79 bb 891fff effffff4c2 storer $0x1fff,_store_regs
1215: 1171 00013B82 # asm("stf _sgl_st_acc"); /* save the acc */
1216: 1172 00013B82 26 effffff4bc stf _sgl_st_acc
1217: 1173 00013B88 # if( force_loop ) /* loop? */
1218: 1174 00013B88 5d effffff4b6 tstl _force_loop
1219: 1175 00013B8E 31 02 jeql L368
1220: 1176 00013B90 # asm("brb _cmpf2_5_lp1");; /* run the loop again */
1221: 1177 00013B90 11 cd brb _cmpf2_5_lp1
1222: 1178 00013B92 L368:
1223: 1179 00013B92 # /*
1224: 1180 00013B92 # * Now compare the stored register values to those that were loaded
1225: 1181 00013B92 # */
1226: 1182 00013B92 # index2 = 0;
1227: 1183 00013B92 4d effffff4ac clrl _index2
1228: 1184 00013B98 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
1229: 1185 00013B98 L369:
1230: 1186 00013B98 0d effffff4a6 50 movl _index2,r0
1231: 1187 00013B9F 0d effffff49f 51 movl _index2,r1
1232: 1188 00013BA6 1d 40effffff497 cmpl _load_regs[r0],_store_regs[r1]
1233: 41effffff491
1234: 1189 00013BB3 21 11 jneq L370
1235: 1190 00013BB5 1d effffff489 0d cmpl _index2,$13
1236: 1191 00013BBC 81 08 jgeq L370
1237: 1192 00013BBE # index2++; /* check reg values */
1238: 1193 00013BBE 6d effffff480 incl _index2
1239: 1194 00013BC4 11 d2 jbr L369
1240: 1195 00013BC6 L370:
1241: 1196 00013BC6 #
1242: 1197 00013BC6 # if( index2 < 13 ) { /* error if index2 < 13 */
1243: 1198 00013BC6 1d effffff478 0d cmpl _index2,$13
1244: 1199 00013BCD 91 03 13 013d jgeq L371
1245: 1200 00013BD2 # errcnt++; /* bump the error count */
1246: 1201 00013BD2 6d effffff46c incl _errcnt
1247: 1202 00013BD8 # if ( prt_error ) {
1248: 1203 00013BD8 5d effffff466 tstl _prt_error
1249: 1204 00013BDE 21 03 13 0106 jeql L372
1250: 1205 00013BE3 # writes(" \n"); /* start a new print line */
1251: 1206 00013BE3 .data 1
1252: 1207 0000171b * L373:
1253: 1208 0000171b * 200A00 .ascii " \12\0"
1254: 1209 0000171e * .text
1255: 1210 00013BE3 dd 8f0000171b pushl $L373
1256: 1211 00013BE9 fe 08 effffff454 callf $8,_writes
1257: 1212 00013BF0 # writes("cycle: ");
1258: 1213 00013BF0 .data 1
1259: 1214 0000171e * L374:
1260: 1215 0000171e * 6379636C653A2000 .ascii "cycle: \0"
1261: 1216 00001726 * .text
1262: 1217 00013BF0 dd 8f0000171e pushl $L374
1263: 1218 00013BF6 fe 08 effffff447 callf $8,_writes
1264: 1219 00013BFD # writed( cycle );
1265: 1220 00013BFD dd effffff441 pushl _cycle
1266: 1221 00013C03 fe 08 effffff43a callf $8,_writed
1267: 1222 00013C0A # writes(", CMPF2 test ");
1268: 1223 00013C0A .data 1
1269: 1224 00001726 * L375:
1270: 1225 00001726 * 2C20434D50463220746573742 .ascii ", CMPF2 test \0"
1271: 000
1272: 1226 00001734 * .text
1273: 1227 00013C0A dd 8f00001726 pushl $L375
1274: 1228 00013C10 fe 08 effffff42d callf $8,_writes
1275: 1229 00013C17 # writed( test_no );
1276: 1230 00013C17 dd effffff427 pushl _test_no
1277: 1231 00013C1D fe 08 effffff420 callf $8,_writed
1278: 1232 00013C24 # writes(", subtest 5 - A REGISTER WAS MODIFIED\n");
1279: 1233 00013C24 .data 1
1280: 1234 00001734 * L376:
1281: 1235 00001734 * 2C20737562746573742035202 .ascii ", subtest 5 - A REGISTER WAS MODIFIED\12\0"
1282: D204120524547495354455220
1283: 574153204D4F4449464945440
1284: A00
1285: 1236 0000175b * .text
1286: 1237 00013C24 dd 8f00001734 pushl $L376
1287: 1238 00013C2A fe 08 effffff413 callf $8,_writes
1288: 1239 00013C31 # print_cmpf2_data();
1289: 1240 00013C31 fe 04 ef0000076e callf $4,_print_cmpf2_data
1290: 1241 00013C38 # writec('\n');
1291: 1242 00013C38 dd 0a pushl $10
1292: 1243 00013C3A fe 08 effffff403 callf $8,_writec
1293: 1244 00013C41 # writes(" final Acc = ");
1294: 1245 00013C41 .data 1
1295: 1246 0000175b * L377:
1296: 1247 0000175b * 20202066696E616C204163632 .ascii " final Acc = \0"
1297: 03D2000
1298: 1248 0000176b * .text
1299: 1249 00013C41 dd 8f0000175b pushl $L377
1300: 1250 00013C47 fe 08 effffff3f6 callf $8,_writes
1301: 1251 00013C4E # write32h( sgl_st_acc );
1302: 1252 00013C4E dd effffff3f0 pushl _sgl_st_acc
1303: 1253 00013C54 fe 08 effffff3e9 callf $8,_write32h
1304: 1254 00013C5B # writes(", operand 2 = ");
1305: 1255 00013C5B .data 1
1306: 1256 0000176b * L378:
1307: 1257 0000176b * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
1308: 03D2000
1309: 1258 0000177b * .text
1310: 1259 00013C5B dd 8f0000176b pushl $L378
1311: 1260 00013C61 fe 08 effffff3dc callf $8,_writes
1312: 1261 00013C68 # write32h( sgl_value_2 );
1313: 1262 00013C68 dd effffff3d6 pushl _sgl_value_2
1314: 1263 00013C6E fe 08 effffff3cf callf $8,_write32h
1315: 1264 00013C75 # writec('\n');
1316: 1265 00013C75 dd 0a pushl $10
1317: 1266 00013C77 fe 08 effffff3c6 callf $8,_writec
1318: 1267 00013C7E # writes("register ");
1319: 1268 00013C7E .data 1
1320: 1269 0000177b * L379:
1321: 1270 0000177b * 72656769737465722000 .ascii "register \0"
1322: 1271 00001785 * .text
1323: 1272 00013C7E dd 8f0000177b pushl $L379
1324: 1273 00013C84 fe 08 effffff3b9 callf $8,_writes
1325: 1274 00013C8B # writed( index2 );
1326: 1275 00013C8B dd effffff3b3 pushl _index2
1327: 1276 00013C91 fe 08 effffff3ac callf $8,_writed
1328: 1277 00013C98 # writes(" = ");
1329: 1278 00013C98 .data 1
1330: 1279 00001785 * L380:
1331: 1280 00001785 * 203D2000 .ascii " = \0"
1332: 1281 00001789 * .text
1333: 1282 00013C98 dd 8f00001785 pushl $L380
1334: 1283 00013C9E fe 08 effffff39f callf $8,_writes
1335: 1284 00013CA5 # write32h( store_regs[ index2 ] );
1336: 1285 00013CA5 0d effffff399 50 movl _index2,r0
1337: 1286 00013CAC dd 40effffff391 pushl _store_regs[r0]
1338: 1287 00013CB3 fe 08 effffff38a callf $8,_write32h
1339: 1288 00013CBA # writes(", should be = ");
1340: 1289 00013CBA .data 1
1341: 1290 00001789 * L381:
1342: 1291 00001789 * 2C202073686F756C642062652 .ascii ", should be = \0"
1343: 03D2000
1344: 1292 00001799 * .text
1345: 1293 00013CBA dd 8f00001789 pushl $L381
1346: 1294 00013CC0 fe 08 effffff37d callf $8,_writes
1347: 1295 00013CC7 # write32h( load_regs[ index2 ] );
1348: 1296 00013CC7 0d effffff377 50 movl _index2,r0
1349: 1297 00013CCE dd 40effffff36f pushl _load_regs[r0]
1350: 1298 00013CD5 fe 08 effffff368 callf $8,_write32h
1351: 1299 00013CDC # writes("\n");
1352: 1300 00013CDC .data 1
1353: 1301 00001799 * L382:
1354: 1302 00001799 * 0A00 .ascii "\12\0"
1355: 1303 0000179b * .text
1356: 1304 00013CDC dd 8f00001799 pushl $L382
1357: 1305 00013CE2 fe 08 effffff35b callf $8,_writes
1358: 1306 00013CE9 # }
1359: 1307 00013CE9 # if ( halt_flg )
1360: 1308 00013CE9 L372:
1361: 1309 00013CE9 5d effffff355 tstl _halt_flg
1362: 1310 00013CEF 31 09 jeql L383
1363: 1311 00013CF1 # cmpf2_er_halt( BAD_REG_HLT ); /* halt on the error */
1364: 1312 00013CF1 dd 02 pushl $2
1365: 1313 00013CF3 fe 08 ef000006e8 callf $8,_cmpf2_er_halt
1366: 1314 00013CFA # if ( loop_on_err )
1367: 1315 00013CFA L383:
1368: 1316 00013CFA 5d effffff344 tstl _loop_on_err
1369: 1317 00013D00 31 0d jeql L384
1370: 1318 00013D02 # {
1371: 1319 00013D02 # force_loop = TRUE; /* set the force loop flag */
1372: 1320 00013D02 0d 01 effffff33b movl $1,_force_loop
1373: 1321 00013D09 # asm("jmp _cmpf2_5_lp1"); /* and loop */
1374: 1322 00013D09 71 effffffe50 jmp _cmpf2_5_lp1
1375: 1323 00013D0F # }; /* end of loop-on-error */
1376: 1324 00013D0F L384:
1377: 1325 00013D0F # } /* end of compare error */
1378: 1326 00013D0F # } while( index++ < max_cmpf_1_index );
1379: 1327 00013D0F L371:
1380: 1328 00013D0F L366:
1381: 1329 00013D0F 0d effffff32f 50 movl _index,r0
1382: 1330 00013D16 6d effffff328 incl _index
1383: 1331 00013D1C 1d 50 effffff321 cmpl r0,_max_cmpf_1_index
1384: 1332 00013D23 81 03 13 fe11 jlss L367
1385: 1333 00013D28 L365:
1386: 1334 00013D28 # } /* end of subtest 5 */
1387: 1335 00013D28 40 ret#2
1388: 1336 00013D29 .set L360,0x0
1389: 1337 00013D29 L362:
1390: 1338 00013D29 13 fded jbr L363
1391: 1339 00013D2C .data
1392: 1340 00001458 * .text
1393: 1341 00013D2C .align 1
1394: 1342 00013D2C .globl _cmpf2_6
1395: 1343 00013D2C _cmpf2_6:
1396: 1344 00013D2C 0000 .word L385
1397: 1345 00013D2E #
1398: 1346 00013D2E #
1399: 1347 00013D2E #
1400: 1348 00013D2E # /****************************************************************************
1401: 1349 00013D2E # *
1402: 1350 00013D2E # * SUBTEST 6 - CMPF2 test Accumulator stability test
1403: 1351 00013D2E # *
1404: 1352 00013D2E # ****************************************************************************/
1405: 1353 00013D2E # cmpf2_6()
1406: 1354 00013D2E # {
1407: 1355 00013D2E 13 01e7 jbr L387
1408: 1356 00013D31 L388:
1409: 1357 00013D31 # force_loop = FALSE;
1410: 1358 00013D31 4d effffff30d clrl _force_loop
1411: 1359 00013D37 # subtest = 6;
1412: 1360 00013D37 0d 06 effffff306 movl $6,_subtest
1413: 1361 00013D3E # index = 0;
1414: 1362 00013D3E 4d effffff300 clrl _index
1415: 1363 00013D44 # do
1416: 1364 00013D44 L391:
1417: 1365 00013D44 # {
1418: 1366 00013D44 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
1419: 1367 00013D44 5c 0c effffff2f9 50 mull3 $12,_index,r0
1420: 1368 00013D4C 0d e000000000 effffff2ed movl _cmpf_1_data(r0),_sgl_value_1
1421: 1369 00013D57 # sgl_value_2 = cmpf_1_data[index].two;
1422: 1370 00013D57 5c 0c effffff2e6 50 mull3 $12,_index,r0
1423: 1371 00013D5F 0d e000000004 effffff2da movl _cmpf_1_data+4(r0),_sgl_value_2
1424: 1372 00013D6A # index2 = 0; /* clear Acc. data index */
1425: 1373 00013D6A 4d effffff2d4 clrl _index2
1426: 1374 00013D70 # do
1427: 1375 00013D70 L394:
1428: 1376 00013D70 # {
1429: 1377 00013D70 # sgl_ld_acc = ldf_1_data[index2].ld; /* get the Accumulator data */
1430: 1378 00013D70 0d effffff2ce 50 movl _index2,r0
1431: 1379 00013D77 48 03 50 50 shll $3,r0,r0
1432: 1380 00013D7B 0d e000000000 effffff2be movl _ldf_1_data(r0),_sgl_ld_acc
1433: 1381 00013D86 # sgl_expected = ldf_1_data[index2++].exp; /* get expected Acc. */
1434: 1382 00013D86 0d effffff2b8 50 movl _index2,r0
1435: 1383 00013D8D 48 03 50 50 shll $3,r0,r0
1436: 1384 00013D91 0d e000000004 effffff2a8 movl _ldf_1_data+4(r0),_sgl_expected
1437: 1385 00013D9C 6d effffff2a2 incl _index2
1438: 1386 00013DA2 # /*
1439: 1387 00013DA2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1440: 1388 00013DA2 # * The force loop flag is set after the first error.
1441: 1389 00013DA2 # */
1442: 1390 00013DA2 # asm("_cmpf2_6_lp1:");
1443: 1391 00013DA2 _cmpf2_6_lp1:
1444: 1392 00013DA2 # asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
1445: 1393 00013DA2 0d effffff29c 53 movl _sgl_ld_acc,r3
1446: 1394 00013DA9 # asm("ldf r3"); /* load the accumulator */
1447: 1395 00013DA9 06 53 ldf r3
1448: 1396 00013DAB # asm("cmpf2 _sgl_value_1,_sgl_value_2");/* compare the operands */
1449: 1397 00013DAB 46 effffff293 effffff28e cmpf2 _sgl_value_1,_sgl_value_2
1450: 1398 00013DB6 # asm("stf _sgl_st_acc"); /* store the accumulator */
1451: 1399 00013DB6 26 effffff288 stf _sgl_st_acc
1452: 1400 00013DBC # if( force_loop ) /* loop? */
1453: 1401 00013DBC 5d effffff282 tstl _force_loop
1454: 1402 00013DC2 31 02 jeql L395
1455: 1403 00013DC4 # asm("brb _cmpf2_6_lp1");; /* run the loop again */
1456: 1404 00013DC4 11 dc brb _cmpf2_6_lp1
1457: 1405 00013DC6 L395:
1458: 1406 00013DC6 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1459: 1407 00013DC6 1d effffff278 effffff273 cmpl _sgl_st_acc,_sgl_expected
1460: 1408 00013DD1 21 03 13 010f jeql L396
1461: 1409 00013DD6 # errcnt++; /* bump the error count */
1462: 1410 00013DD6 6d effffff268 incl _errcnt
1463: 1411 00013DDC # if ( prt_error ) {
1464: 1412 00013DDC 5d effffff262 tstl _prt_error
1465: 1413 00013DE2 21 03 13 00d8 jeql L397
1466: 1414 00013DE7 # writes(" \n"); /* start a new print line */
1467: 1415 00013DE7 .data 1
1468: 1416 0000179b * L398:
1469: 1417 0000179b * 200A00 .ascii " \12\0"
1470: 1418 0000179e * .text
1471: 1419 00013DE7 dd 8f0000179b pushl $L398
1472: 1420 00013DED fe 08 effffff250 callf $8,_writes
1473: 1421 00013DF4 # writes("cycle: ");
1474: 1422 00013DF4 .data 1
1475: 1423 0000179e * L399:
1476: 1424 0000179e * 6379636C653A2000 .ascii "cycle: \0"
1477: 1425 000017a6 * .text
1478: 1426 00013DF4 dd 8f0000179e pushl $L399
1479: 1427 00013DFA fe 08 effffff243 callf $8,_writes
1480: 1428 00013E01 # writed( cycle );
1481: 1429 00013E01 dd effffff23d pushl _cycle
1482: 1430 00013E07 fe 08 effffff236 callf $8,_writed
1483: 1431 00013E0E # writes(" CMPF2 test ");
1484: 1432 00013E0E .data 1
1485: 1433 000017a6 * L400:
1486: 1434 000017a6 * 2020434D50463220746573742 .ascii " CMPF2 test \0"
1487: 000
1488: 1435 000017b4 * .text
1489: 1436 00013E0E dd 8f000017a6 pushl $L400
1490: 1437 00013E14 fe 08 effffff229 callf $8,_writes
1491: 1438 00013E1B # writed( test_no );
1492: 1439 00013E1B dd effffff223 pushl _test_no
1493: 1440 00013E21 fe 08 effffff21c callf $8,_writed
1494: 1441 00013E28 # writes(", subtest 6 (Acc. Corr.) - THE ACC WAS MODIFIED\n");
1495: 1442 00013E28 .data 1
1496: 1443 000017b4 * L401:
1497: 1444 000017b4 * 2C20737562746573742036202 .ascii ", subtest 6 (Acc. Corr.) - THE ACC WAS MODIFIED\12\0"
1498: 84163632E20436F72722E2920
1499: 2D20544845204143432057415
1500: 3204D4F4449464945440A00
1501: 1445 000017e5 * .text
1502: 1446 00013E28 dd 8f000017b4 pushl $L401
1503: 1447 00013E2E fe 08 effffff20f callf $8,_writes
1504: 1448 00013E35 # print_cmpf2_data();
1505: 1449 00013E35 fe 04 ef0000056a callf $4,_print_cmpf2_data
1506: 1450 00013E3C # writes(", index = ");
1507: 1451 00013E3C .data 1
1508: 1452 000017e5 * L402:
1509: 1453 000017e5 * 2C2020696E646578203D2000 .ascii ", index = \0"
1510: 1454 000017f1 * .text
1511: 1455 00013E3C dd 8f000017e5 pushl $L402
1512: 1456 00013E42 fe 08 effffff1fb callf $8,_writes
1513: 1457 00013E49 # writed( index );
1514: 1458 00013E49 dd effffff1f5 pushl _index
1515: 1459 00013E4F fe 08 effffff1ee callf $8,_writed
1516: 1460 00013E56 # writec('\n');
1517: 1461 00013E56 dd 0a pushl $10
1518: 1462 00013E58 fe 08 effffff1e5 callf $8,_writec
1519: 1463 00013E5F # writes(" final Acc = ");
1520: 1464 00013E5F .data 1
1521: 1465 000017f1 * L403:
1522: 1466 000017f1 * 20202066696E616C204163632 .ascii " final Acc = \0"
1523: 03D2000
1524: 1467 00001801 * .text
1525: 1468 00013E5F dd 8f000017f1 pushl $L403
1526: 1469 00013E65 fe 08 effffff1d8 callf $8,_writes
1527: 1470 00013E6C # write32h( sgl_st_acc );
1528: 1471 00013E6C dd effffff1d2 pushl _sgl_st_acc
1529: 1472 00013E72 fe 08 effffff1cb callf $8,_write32h
1530: 1473 00013E79 # writes(", operand 2 = ");
1531: 1474 00013E79 .data 1
1532: 1475 00001801 * L404:
1533: 1476 00001801 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
1534: 03D2000
1535: 1477 00001811 * .text
1536: 1478 00013E79 dd 8f00001801 pushl $L404
1537: 1479 00013E7F fe 08 effffff1be callf $8,_writes
1538: 1480 00013E86 # write32h( sgl_value_2 );
1539: 1481 00013E86 dd effffff1b8 pushl _sgl_value_2
1540: 1482 00013E8C fe 08 effffff1b1 callf $8,_write32h
1541: 1483 00013E93 # writec('\n');
1542: 1484 00013E93 dd 0a pushl $10
1543: 1485 00013E95 fe 08 effffff1a8 callf $8,_writec
1544: 1486 00013E9C # writes("expected Acc = ");
1545: 1487 00013E9C .data 1
1546: 1488 00001811 * L405:
1547: 1489 00001811 * 6578706563746564204163632 .ascii "expected Acc = \0"
1548: 03D2000
1549: 1490 00001821 * .text
1550: 1491 00013E9C dd 8f00001811 pushl $L405
1551: 1492 00013EA2 fe 08 effffff19b callf $8,_writes
1552: 1493 00013EA9 # write32h( sgl_expected );
1553: 1494 00013EA9 dd effffff195 pushl _sgl_expected
1554: 1495 00013EAF fe 08 effffff18e callf $8,_write32h
1555: 1496 00013EB6 # writec('\n');
1556: 1497 00013EB6 dd 0a pushl $10
1557: 1498 00013EB8 fe 08 effffff185 callf $8,_writec
1558: 1499 00013EBF # }
1559: 1500 00013EBF # if ( halt_flg ) /* halt on error? */
1560: 1501 00013EBF L397:
1561: 1502 00013EBF 5d effffff17f tstl _halt_flg
1562: 1503 00013EC5 31 09 jeql L406
1563: 1504 00013EC7 # cmpf2_er_halt( BAD_ACC_HLT );
1564: 1505 00013EC7 dd 01 pushl $1
1565: 1506 00013EC9 fe 08 ef00000512 callf $8,_cmpf2_er_halt
1566: 1507 00013ED0 # if ( loop_on_err )
1567: 1508 00013ED0 L406:
1568: 1509 00013ED0 5d effffff16e tstl _loop_on_err
1569: 1510 00013ED6 31 0d jeql L407
1570: 1511 00013ED8 # {
1571: 1512 00013ED8 # force_loop = TRUE; /* set the force loop flag */
1572: 1513 00013ED8 0d 01 effffff165 movl $1,_force_loop
1573: 1514 00013EDF # asm("jmp _cmpf2_6_lp1"); /* and loop */
1574: 1515 00013EDF 71 effffffebd jmp _cmpf2_6_lp1
1575: 1516 00013EE5 # }; /* end of loop-on-error */
1576: 1517 00013EE5 L407:
1577: 1518 00013EE5 # } /* end of compare error */
1578: 1519 00013EE5 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
1579: 1520 00013EE5 L396:
1580: 1521 00013EE5 L393:
1581: 1522 00013EE5 1d effffff159 0a cmpl _index2,$10
1582: 1523 00013EEC 81 10 jgeq L9995
1583: 1524 00013EEE 1d effffff150 effffff14b cmpl _index2,_max_ldf_1_index
1584: 1525 00013EF9 81 03 13 fe72 jlss L394
1585: 1526 00013EFE L9995:
1586: 1527 00013EFE L392:
1587: 1528 00013EFE # } while( index++ < max_cmpf_1_index );
1588: 1529 00013EFE L390:
1589: 1530 00013EFE 0d effffff140 50 movl _index,r0
1590: 1531 00013F05 6d effffff139 incl _index
1591: 1532 00013F0B 1d 50 effffff132 cmpl r0,_max_cmpf_1_index
1592: 1533 00013F12 81 03 13 fe2d jlss L391
1593: 1534 00013F17 L389:
1594: 1535 00013F17 # } /* end of subtest 6 */
1595: 1536 00013F17 40 ret#2
1596: 1537 00013F18 .set L385,0x0
1597: 1538 00013F18 L387:
1598: 1539 00013F18 13 fe16 jbr L388
1599: 1540 00013F1B .data
1600: 1541 00001458 * .text
1601: 1542 00013F1B 00 .align 1
1602: 1543 00013F1C .globl _cmpf2_7
1603: 1544 00013F1C _cmpf2_7:
1604: 1545 00013F1C 0000 .word L408
1605: 1546 00013F1E #
1606: 1547 00013F1E #
1607: 1548 00013F1E #
1608: 1549 00013F1E # /****************************************************************************
1609: 1550 00013F1E # *
1610: 1551 00013F1E # * SUBTEST 7 - CMPF2 test - piped entry
1611: 1552 00013F1E # *
1612: 1553 00013F1E # ****************************************************************************/
1613: 1554 00013F1E # cmpf2_7()
1614: 1555 00013F1E # {
1615: 1556 00013F1E 13 028e jbr L410
1616: 1557 00013F21 L411:
1617: 1558 00013F21 # force_loop = FALSE;
1618: 1559 00013F21 4d effffff11d clrl _force_loop
1619: 1560 00013F27 # subtest = 7;
1620: 1561 00013F27 0d 07 effffff116 movl $7,_subtest
1621: 1562 00013F2E # index = 0;
1622: 1563 00013F2E 4d effffff110 clrl _index
1623: 1564 00013F34 # do
1624: 1565 00013F34 L414:
1625: 1566 00013F34 # {
1626: 1567 00013F34 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
1627: 1568 00013F34 5c 0c effffff109 50 mull3 $12,_index,r0
1628: 1569 00013F3C 0d e000000000 effffff0fd movl _cmpf_1_data(r0),_sgl_value_1
1629: 1570 00013F47 # sgl_value_2 = cmpf_1_data[index].two;
1630: 1571 00013F47 5c 0c effffff0f6 50 mull3 $12,_index,r0
1631: 1572 00013F4F 0d e000000004 effffff0ea movl _cmpf_1_data+4(r0),_sgl_value_2
1632: 1573 00013F5A # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
1633: 1574 00013F5A 5c 0c effffff0e3 50 mull3 $12,_index,r0
1634: 1575 00013F62 0d e000000008 effffff0d7 movl _cmpf_1_data+8(r0),_sgl_expected
1635: 1576 00013F6D # index2 = 0; /* clear Acc. data index */
1636: 1577 00013F6D 4d effffff0d1 clrl _index2
1637: 1578 00013F73 # do
1638: 1579 00013F73 L417:
1639: 1580 00013F73 # {
1640: 1581 00013F73 # sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
1641: 1582 00013F73 0d effffff0cb 50 movl _index2,r0
1642: 1583 00013F7A 48 03 50 50 shll $3,r0,r0
1643: 1584 00013F7E 0d e000000000 effffff0bb movl _ldf_1_data(r0),_sgl_ld_acc
1644: 1585 00013F89 6d effffff0b5 incl _index2
1645: 1586 00013F8F # status_index = 0; /* clear the status index */
1646: 1587 00013F8F 4d effffff0af clrl _status_index
1647: 1588 00013F95 # do
1648: 1589 00013F95 L420:
1649: 1590 00013F95 # {
1650: 1591 00013F95 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
1651: 1592 00013F95 0d effffff0a9 50 movl _status_index,r0
1652: 1593 00013F9C 0d 40effffff0a1 movl _status_array[r0],_sgl_dummy1
1653: effffff09c
1654: 1594 00013FA8 # /*
1655: 1595 00013FA8 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1656: 1596 00013FA8 # * The force loop flag is set after the first error.
1657: 1597 00013FA8 # */
1658: 1598 00013FA8 # asm("_cmpf2_7_lp1:");
1659: 1599 00013FA8 _cmpf2_7_lp1:
1660: 1600 00013FA8 # asm("movl $0,r0"); /* zero the reg */
1661: 1601 00013FA8 0d 00 50 movl $0,r0
1662: 1602 00013FAB # asm("ldf r0"); /* load a zero in the acc */
1663: 1603 00013FAB 06 50 ldf r0
1664: 1604 00013FAD # asm("addf _sgl_ld_acc"); /* add initial data to acc */
1665: 1605 00013FAD c6 effffff091 addf _sgl_ld_acc
1666: 1606 00013FB3 # asm("tstl _sgl_dummy1"); /* generate initial status */
1667: 1607 00013FB3 5d effffff08b tstl _sgl_dummy1
1668: 1608 00013FB9 # asm("movpsl _init_psl"); /* save the initial status */
1669: 1609 00013FB9 cd effffff085 movpsl _init_psl
1670: 1610 00013FBF # asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
1671: 1611 00013FBF 46 effffff07f effffff07a cmpf2 _sgl_value_1,_sgl_value_2
1672: 1612 00013FCA # asm("movpsl _psl_val"); /* save the final status */
1673: 1613 00013FCA cd effffff074 movpsl _psl_val
1674: 1614 00013FD0 # asm("stf _sgl_st_acc"); /* save the acc */
1675: 1615 00013FD0 26 effffff06e stf _sgl_st_acc
1676: 1616 00013FD6 # if( force_loop ) /* loop? */
1677: 1617 00013FD6 5d effffff068 tstl _force_loop
1678: 1618 00013FDC 31 02 jeql L421
1679: 1619 00013FDE # asm("brb _cmpf2_7_lp1");; /* run the loop again */
1680: 1620 00013FDE 11 c8 brb _cmpf2_7_lp1
1681: 1621 00013FE0 L421:
1682: 1622 00013FE0 # exp_psl = init_psl; /* get the initial PSL */
1683: 1623 00013FE0 0d effffff05e effffff059 movl _init_psl,_exp_psl
1684: 1624 00013FEB # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
1685: 1625 00013FEB ac 88f3 effffff051 andl2 $-13,_exp_psl
1686: 1626 00013FF3 # if( sgl_expected == ZERO )
1687: 1627 00013FF3 1d effffff04b 04 cmpl _sgl_expected,$4
1688: 1628 00013FFA 21 07 jneq L422
1689: 1629 00013FFC # exp_psl |= PSL_Z; /* expect the ZERO bit set */
1690: 1630 00013FFC 8c 04 effffff041 orl2 $4,_exp_psl
1691: 1631 00014003 # if( sgl_expected == NEGATIVE )
1692: 1632 00014003 L422:
1693: 1633 00014003 1d effffff03b 08 cmpl _sgl_expected,$8
1694: 1634 0001400A 21 07 jneq L423
1695: 1635 0001400C # exp_psl |= PSL_N; /* expect the NEG bit set */
1696: 1636 0001400C 8c 08 effffff031 orl2 $8,_exp_psl
1697: 1637 00014013 # if( psl_val != exp_psl ) /* COMPARE the values */
1698: 1638 00014013 L423:
1699: 1639 00014013 1d effffff02b effffff026 cmpl _psl_val,_exp_psl
1700: 1640 0001401E 21 03 13 0144 jeql L424
1701: 1641 00014023 # {
1702: 1642 00014023 # errcnt++; /* bump the error count */
1703: 1643 00014023 6d effffff01b incl _errcnt
1704: 1644 00014029 # if ( prt_error ) {
1705: 1645 00014029 5d effffff015 tstl _prt_error
1706: 1646 0001402F 21 03 13 0110 jeql L425
1707: 1647 00014034 # writes(" \n"); /* start a new print line */
1708: 1648 00014034 .data 1
1709: 1649 00001821 * L426:
1710: 1650 00001821 * 200A00 .ascii " \12\0"
1711: 1651 00001824 * .text
1712: 1652 00014034 dd 8f00001821 pushl $L426
1713: 1653 0001403A fe 08 effffff003 callf $8,_writes
1714: 1654 00014041 # writes("cycle: ");
1715: 1655 00014041 .data 1
1716: 1656 00001824 * L427:
1717: 1657 00001824 * 6379636C653A2000 .ascii "cycle: \0"
1718: 1658 0000182c * .text
1719: 1659 00014041 dd 8f00001824 pushl $L427
1720: 1660 00014047 fe 08 efffffeff6 callf $8,_writes
1721: 1661 0001404E # writed( cycle );
1722: 1662 0001404E dd efffffeff0 pushl _cycle
1723: 1663 00014054 fe 08 efffffefe9 callf $8,_writed
1724: 1664 0001405B # writes(" CMPF2 test ");
1725: 1665 0001405B .data 1
1726: 1666 0000182c * L428:
1727: 1667 0000182c * 2020434D50463220746573742 .ascii " CMPF2 test \0"
1728: 000
1729: 1668 0000183a * .text
1730: 1669 0001405B dd 8f0000182c pushl $L428
1731: 1670 00014061 fe 08 efffffefdc callf $8,_writes
1732: 1671 00014068 # writed( test_no );
1733: 1672 00014068 dd efffffefd6 pushl _test_no
1734: 1673 0001406E fe 08 efffffefcf callf $8,_writed
1735: 1674 00014075 # writes(", subtest 7 (Piped Entry) - BAD FINAL PSL\n");
1736: 1675 00014075 .data 1
1737: 1676 0000183a * L429:
1738: 1677 0000183a * 2C20737562746573742037202 .ascii ", subtest 7 (Piped Entry) - BAD FINAL PSL\12\0"
1739: 8506970656420456E74727929
1740: 202D204241442046494E414C2
1741: 050534C0A00
1742: 1678 00001865 * .text
1743: 1679 00014075 dd 8f0000183a pushl $L429
1744: 1680 0001407B fe 08 efffffefc2 callf $8,_writes
1745: 1681 00014082 # print_cmpf2_data();
1746: 1682 00014082 fe 04 ef0000031d callf $4,_print_cmpf2_data
1747: 1683 00014089 # writes(", data index = ");
1748: 1684 00014089 .data 1
1749: 1685 00001865 * L430:
1750: 1686 00001865 * 2C20206461746120696E64657 .ascii ", data index = \0"
1751: 8203D2000
1752: 1687 00001876 * .text
1753: 1688 00014089 dd 8f00001865 pushl $L430
1754: 1689 0001408F fe 08 efffffefae callf $8,_writes
1755: 1690 00014096 # writed( index );
1756: 1691 00014096 dd efffffefa8 pushl _index
1757: 1692 0001409C fe 08 efffffefa1 callf $8,_writed
1758: 1693 000140A3 # writec('\n');
1759: 1694 000140A3 dd 0a pushl $10
1760: 1695 000140A5 fe 08 efffffef98 callf $8,_writec
1761: 1696 000140AC # writes(" final Acc = ");
1762: 1697 000140AC .data 1
1763: 1698 00001876 * L431:
1764: 1699 00001876 * 20202066696E616C204163632 .ascii " final Acc = \0"
1765: 03D2000
1766: 1700 00001886 * .text
1767: 1701 000140AC dd 8f00001876 pushl $L431
1768: 1702 000140B2 fe 08 efffffef8b callf $8,_writes
1769: 1703 000140B9 # write32h( sgl_st_acc );
1770: 1704 000140B9 dd efffffef85 pushl _sgl_st_acc
1771: 1705 000140BF fe 08 efffffef7e callf $8,_write32h
1772: 1706 000140C6 # writes(", operand 2 = ");
1773: 1707 000140C6 .data 1
1774: 1708 00001886 * L432:
1775: 1709 00001886 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
1776: 03D2000
1777: 1710 00001896 * .text
1778: 1711 000140C6 dd 8f00001886 pushl $L432
1779: 1712 000140CC fe 08 efffffef71 callf $8,_writes
1780: 1713 000140D3 # write32h( sgl_value_2 );
1781: 1714 000140D3 dd efffffef6b pushl _sgl_value_2
1782: 1715 000140D9 fe 08 efffffef64 callf $8,_write32h
1783: 1716 000140E0 # writec('\n');
1784: 1717 000140E0 dd 0a pushl $10
1785: 1718 000140E2 fe 08 efffffef5b callf $8,_writec
1786: 1719 000140E9 # writes(" initial PSL = ");
1787: 1720 000140E9 .data 1
1788: 1721 00001896 * L433:
1789: 1722 00001896 * 20696E697469616C2050534C2 .ascii " initial PSL = \0"
1790: 03D2000
1791: 1723 000018a6 * .text
1792: 1724 000140E9 dd 8f00001896 pushl $L433
1793: 1725 000140EF fe 08 efffffef4e callf $8,_writes
1794: 1726 000140F6 # write32h( init_psl );
1795: 1727 000140F6 dd efffffef48 pushl _init_psl
1796: 1728 000140FC fe 08 efffffef41 callf $8,_write32h
1797: 1729 00014103 # writes(", final PSL = ");
1798: 1730 00014103 .data 1
1799: 1731 000018a6 * L434:
1800: 1732 000018a6 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
1801: 03D2000
1802: 1733 000018b6 * .text
1803: 1734 00014103 dd 8f000018a6 pushl $L434
1804: 1735 00014109 fe 08 efffffef34 callf $8,_writes
1805: 1736 00014110 # write32h( psl_val );
1806: 1737 00014110 dd efffffef2e pushl _psl_val
1807: 1738 00014116 fe 08 efffffef27 callf $8,_write32h
1808: 1739 0001411D # writes(", expected PSL = ");
1809: 1740 0001411D .data 1
1810: 1741 000018b6 * L435:
1811: 1742 000018b6 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
1812: 0534C203D2000
1813: 1743 000018c9 * .text
1814: 1744 0001411D dd 8f000018b6 pushl $L435
1815: 1745 00014123 fe 08 efffffef1a callf $8,_writes
1816: 1746 0001412A # write32h( exp_psl );
1817: 1747 0001412A dd efffffef14 pushl _exp_psl
1818: 1748 00014130 fe 08 efffffef0d callf $8,_write32h
1819: 1749 00014137 # writes(" \n");
1820: 1750 00014137 .data 1
1821: 1751 000018c9 * L436:
1822: 1752 000018c9 * 200A00 .ascii " \12\0"
1823: 1753 000018cc * .text
1824: 1754 00014137 dd 8f000018c9 pushl $L436
1825: 1755 0001413D fe 08 efffffef00 callf $8,_writes
1826: 1756 00014144 # }
1827: 1757 00014144 # if ( halt_flg )
1828: 1758 00014144 L425:
1829: 1759 00014144 5d efffffeefa tstl _halt_flg
1830: 1760 0001414A 31 09 jeql L437
1831: 1761 0001414C # cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
1832: 1762 0001414C dd 03 pushl $3
1833: 1763 0001414E fe 08 ef0000028d callf $8,_cmpf2_er_halt
1834: 1764 00014155 # if ( loop_on_err )
1835: 1765 00014155 L437:
1836: 1766 00014155 5d efffffeee9 tstl _loop_on_err
1837: 1767 0001415B 31 0a jeql L438
1838: 1768 0001415D # {
1839: 1769 0001415D # force_loop = TRUE; /* set the force loop flag */
1840: 1770 0001415D 0d 01 efffffeee0 movl $1,_force_loop
1841: 1771 00014164 # asm("brw _cmpf2_7_lp1"); /* and loop */
1842: 1772 00014164 13 fe41 brw _cmpf2_7_lp1
1843: 1773 00014167 # }; /* end of loop-on-error */
1844: 1774 00014167 L438:
1845: 1775 00014167 # } /* end of compare error */
1846: 1776 00014167 # } while( ++status_index < 3 );
1847: 1777 00014167 L424:
1848: 1778 00014167 L419:
1849: 1779 00014167 6d efffffeed7 incl _status_index
1850: 1780 0001416D 0d efffffeed1 50 movl _status_index,r0
1851: 1781 00014174 1d 50 03 cmpl r0,$3
1852: 1782 00014177 81 03 13 fe19 jlss L420
1853: 1783 0001417C L418:
1854: 1784 0001417C # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
1855: 1785 0001417C L416:
1856: 1786 0001417C 1d efffffeec2 0a cmpl _index2,$10
1857: 1787 00014183 81 10 jgeq L9994
1858: 1788 00014185 1d efffffeeb9 efffffeeb4 cmpl _index2,_max_ldf_1_index
1859: 1789 00014190 81 03 13 fdde jlss L417
1860: 1790 00014195 L9994:
1861: 1791 00014195 L415:
1862: 1792 00014195 # } while( index++ < max_cmpf_1_index );
1863: 1793 00014195 L413:
1864: 1794 00014195 0d efffffeea9 50 movl _index,r0
1865: 1795 0001419C 6d efffffeea2 incl _index
1866: 1796 000141A2 1d 50 efffffee9b cmpl r0,_max_cmpf_1_index
1867: 1797 000141A9 81 03 13 fd86 jlss L414
1868: 1798 000141AE L412:
1869: 1799 000141AE # } /* end of subtest 7 */
1870: 1800 000141AE 40 ret#2
1871: 1801 000141AF .set L408,0x0
1872: 1802 000141AF L410:
1873: 1803 000141AF 13 fd6f jbr L411
1874: 1804 000141B2 .data
1875: 1805 00001458 * .text
1876: 1806 000141B2 .align 1
1877: 1807 000141B2 .globl _cmpf2_8
1878: 1808 000141B2 _cmpf2_8:
1879: 1809 000141B2 0000 .word L439
1880: 1810 000141B4 #
1881: 1811 000141B4 #
1882: 1812 000141B4 #
1883: 1813 000141B4 # /****************************************************************************
1884: 1814 000141B4 # *
1885: 1815 000141B4 # * SUBTEST 8 - CMPF2 piped exit test
1886: 1816 000141B4 # *
1887: 1817 000141B4 # ****************************************************************************/
1888: 1818 000141B4 # cmpf2_8()
1889: 1819 000141B4 # {
1890: 1820 000141B4 13 01ec jbr L441
1891: 1821 000141B7 L442:
1892: 1822 000141B7 # force_loop = FALSE;
1893: 1823 000141B7 4d efffffee87 clrl _force_loop
1894: 1824 000141BD # subtest = 6;
1895: 1825 000141BD 0d 06 efffffee80 movl $6,_subtest
1896: 1826 000141C4 # index = 0;
1897: 1827 000141C4 4d efffffee7a clrl _index
1898: 1828 000141CA # do
1899: 1829 000141CA L445:
1900: 1830 000141CA # {
1901: 1831 000141CA # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
1902: 1832 000141CA 5c 0c efffffee73 50 mull3 $12,_index,r0
1903: 1833 000141D2 0d e000000000 efffffee67 movl _cmpf_1_data(r0),_sgl_value_1
1904: 1834 000141DD # sgl_value_2 = cmpf_1_data[index].two;
1905: 1835 000141DD 5c 0c efffffee60 50 mull3 $12,_index,r0
1906: 1836 000141E5 0d e000000004 efffffee54 movl _cmpf_1_data+4(r0),_sgl_value_2
1907: 1837 000141F0 # index2 = 0; /* clear Acc. data index */
1908: 1838 000141F0 4d efffffee4e clrl _index2
1909: 1839 000141F6 # do
1910: 1840 000141F6 L448:
1911: 1841 000141F6 # {
1912: 1842 000141F6 # sgl_ld_acc = ldf_1_data[index2].ld; /* get the Accumulator data */
1913: 1843 000141F6 0d efffffee48 50 movl _index2,r0
1914: 1844 000141FD 48 03 50 50 shll $3,r0,r0
1915: 1845 00014201 0d e000000000 efffffee38 movl _ldf_1_data(r0),_sgl_ld_acc
1916: 1846 0001420C # sgl_expected = ldf_1_data[index2++].exp; /* get expected Acc. */
1917: 1847 0001420C 0d efffffee32 50 movl _index2,r0
1918: 1848 00014213 48 03 50 50 shll $3,r0,r0
1919: 1849 00014217 0d e000000004 efffffee22 movl _ldf_1_data+4(r0),_sgl_expected
1920: 1850 00014222 6d efffffee1c incl _index2
1921: 1851 00014228 # /*
1922: 1852 00014228 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1923: 1853 00014228 # * The force loop flag is set after the first error.
1924: 1854 00014228 # */
1925: 1855 00014228 # asm("_cmpf2_8_lp1:");
1926: 1856 00014228 _cmpf2_8_lp1:
1927: 1857 00014228 # asm("movl $0,r0"); /* move a zero to r0 */
1928: 1858 00014228 0d 00 50 movl $0,r0
1929: 1859 0001422B # asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
1930: 1860 0001422B 0d efffffee13 53 movl _sgl_ld_acc,r3
1931: 1861 00014232 # asm("ldf r3"); /* load the accumulator */
1932: 1862 00014232 06 53 ldf r3
1933: 1863 00014234 # asm("cmpf2 _sgl_value_1,_sgl_value_2");/* compare the operands */
1934: 1864 00014234 46 efffffee0a efffffee05 cmpf2 _sgl_value_1,_sgl_value_2
1935: 1865 0001423F # asm("addf r0"); /* add a zero to the acc */
1936: 1866 0001423F c6 50 addf r0
1937: 1867 00014241 # asm("stf _sgl_st_acc"); /* store the accumulator */
1938: 1868 00014241 26 efffffedfd stf _sgl_st_acc
1939: 1869 00014247 # if( force_loop ) /* loop? */
1940: 1870 00014247 5d efffffedf7 tstl _force_loop
1941: 1871 0001424D 31 02 jeql L449
1942: 1872 0001424F # asm("brb _cmpf2_8_lp1");; /* run the loop again */
1943: 1873 0001424F 11 d7 brb _cmpf2_8_lp1
1944: 1874 00014251 L449:
1945: 1875 00014251 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1946: 1876 00014251 1d efffffeded efffffede8 cmpl _sgl_st_acc,_sgl_expected
1947: 1877 0001425C 21 03 13 010f jeql L450
1948: 1878 00014261 # errcnt++; /* bump the error count */
1949: 1879 00014261 6d efffffeddd incl _errcnt
1950: 1880 00014267 # if ( prt_error ) {
1951: 1881 00014267 5d efffffedd7 tstl _prt_error
1952: 1882 0001426D 21 03 13 00d8 jeql L451
1953: 1883 00014272 # writes(" \n"); /* start a new print line */
1954: 1884 00014272 .data 1
1955: 1885 000018cc * L452:
1956: 1886 000018cc * 200A00 .ascii " \12\0"
1957: 1887 000018cf * .text
1958: 1888 00014272 dd 8f000018cc pushl $L452
1959: 1889 00014278 fe 08 efffffedc5 callf $8,_writes
1960: 1890 0001427F # writes("cycle: ");
1961: 1891 0001427F .data 1
1962: 1892 000018cf * L453:
1963: 1893 000018cf * 6379636C653A2000 .ascii "cycle: \0"
1964: 1894 000018d7 * .text
1965: 1895 0001427F dd 8f000018cf pushl $L453
1966: 1896 00014285 fe 08 efffffedb8 callf $8,_writes
1967: 1897 0001428C # writed( cycle );
1968: 1898 0001428C dd efffffedb2 pushl _cycle
1969: 1899 00014292 fe 08 efffffedab callf $8,_writed
1970: 1900 00014299 # writes(" CMPF2 test ");
1971: 1901 00014299 .data 1
1972: 1902 000018d7 * L454:
1973: 1903 000018d7 * 2020434D50463220746573742 .ascii " CMPF2 test \0"
1974: 000
1975: 1904 000018e5 * .text
1976: 1905 00014299 dd 8f000018d7 pushl $L454
1977: 1906 0001429F fe 08 efffffed9e callf $8,_writes
1978: 1907 000142A6 # writed( test_no );
1979: 1908 000142A6 dd efffffed98 pushl _test_no
1980: 1909 000142AC fe 08 efffffed91 callf $8,_writed
1981: 1910 000142B3 # writes(", subtest 8 (Piped Exit) - THE ACC WAS MODIFIED\n");
1982: 1911 000142B3 .data 1
1983: 1912 000018e5 * L455:
1984: 1913 000018e5 * 2C20737562746573742038202 .ascii ", subtest 8 (Piped Exit) - THE ACC WAS MODIFIED\12\0"
1985: 8506970656420457869742920
1986: 2D20544845204143432057415
1987: 3204D4F4449464945440A00
1988: 1914 00001916 * .text
1989: 1915 000142B3 dd 8f000018e5 pushl $L455
1990: 1916 000142B9 fe 08 efffffed84 callf $8,_writes
1991: 1917 000142C0 # print_cmpf2_data();
1992: 1918 000142C0 fe 04 ef000000df callf $4,_print_cmpf2_data
1993: 1919 000142C7 # writes(", data index = ");
1994: 1920 000142C7 .data 1
1995: 1921 00001916 * L456:
1996: 1922 00001916 * 2C20206461746120696E64657 .ascii ", data index = \0"
1997: 8203D2000
1998: 1923 00001927 * .text
1999: 1924 000142C7 dd 8f00001916 pushl $L456
2000: 1925 000142CD fe 08 efffffed70 callf $8,_writes
2001: 1926 000142D4 # writed( index );
2002: 1927 000142D4 dd efffffed6a pushl _index
2003: 1928 000142DA fe 08 efffffed63 callf $8,_writed
2004: 1929 000142E1 # writec('\n');
2005: 1930 000142E1 dd 0a pushl $10
2006: 1931 000142E3 fe 08 efffffed5a callf $8,_writec
2007: 1932 000142EA # writes(" final Acc = ");
2008: 1933 000142EA .data 1
2009: 1934 00001927 * L457:
2010: 1935 00001927 * 20202066696E616C204163632 .ascii " final Acc = \0"
2011: 03D2000
2012: 1936 00001937 * .text
2013: 1937 000142EA dd 8f00001927 pushl $L457
2014: 1938 000142F0 fe 08 efffffed4d callf $8,_writes
2015: 1939 000142F7 # write32h( sgl_st_acc );
2016: 1940 000142F7 dd efffffed47 pushl _sgl_st_acc
2017: 1941 000142FD fe 08 efffffed40 callf $8,_write32h
2018: 1942 00014304 # writes(", operand 2 = ");
2019: 1943 00014304 .data 1
2020: 1944 00001937 * L458:
2021: 1945 00001937 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
2022: 03D2000
2023: 1946 00001947 * .text
2024: 1947 00014304 dd 8f00001937 pushl $L458
2025: 1948 0001430A fe 08 efffffed33 callf $8,_writes
2026: 1949 00014311 # write32h( sgl_value_2 );
2027: 1950 00014311 dd efffffed2d pushl _sgl_value_2
2028: 1951 00014317 fe 08 efffffed26 callf $8,_write32h
2029: 1952 0001431E # writec('\n');
2030: 1953 0001431E dd 0a pushl $10
2031: 1954 00014320 fe 08 efffffed1d callf $8,_writec
2032: 1955 00014327 # writes("expected Acc = ");
2033: 1956 00014327 .data 1
2034: 1957 00001947 * L459:
2035: 1958 00001947 * 6578706563746564204163632 .ascii "expected Acc = \0"
2036: 03D2000
2037: 1959 00001957 * .text
2038: 1960 00014327 dd 8f00001947 pushl $L459
2039: 1961 0001432D fe 08 efffffed10 callf $8,_writes
2040: 1962 00014334 # write32h( sgl_expected );
2041: 1963 00014334 dd efffffed0a pushl _sgl_expected
2042: 1964 0001433A fe 08 efffffed03 callf $8,_write32h
2043: 1965 00014341 # writec('\n');
2044: 1966 00014341 dd 0a pushl $10
2045: 1967 00014343 fe 08 efffffecfa callf $8,_writec
2046: 1968 0001434A # }
2047: 1969 0001434A # if ( halt_flg ) /* halt on error? */
2048: 1970 0001434A L451:
2049: 1971 0001434A 5d efffffecf4 tstl _halt_flg
2050: 1972 00014350 31 09 jeql L460
2051: 1973 00014352 # cmpf2_er_halt( BAD_ACC_HLT );
2052: 1974 00014352 dd 01 pushl $1
2053: 1975 00014354 fe 08 ef00000087 callf $8,_cmpf2_er_halt
2054: 1976 0001435B # if ( loop_on_err )
2055: 1977 0001435B L460:
2056: 1978 0001435B 5d efffffece3 tstl _loop_on_err
2057: 1979 00014361 31 0d jeql L461
2058: 1980 00014363 # {
2059: 1981 00014363 # force_loop = TRUE; /* set the force loop flag */
2060: 1982 00014363 0d 01 efffffecda movl $1,_force_loop
2061: 1983 0001436A # asm("jmp _cmpf2_8_lp1"); /* and loop */
2062: 1984 0001436A 71 effffffeb8 jmp _cmpf2_8_lp1
2063: 1985 00014370 # }; /* end of loop-on-error */
2064: 1986 00014370 L461:
2065: 1987 00014370 # } /* end of compare error */
2066: 1988 00014370 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
2067: 1989 00014370 L450:
2068: 1990 00014370 L447:
2069: 1991 00014370 1d efffffecce 0a cmpl _index2,$10
2070: 1992 00014377 81 10 jgeq L9993
2071: 1993 00014379 1d efffffecc5 efffffecc0 cmpl _index2,_max_ldf_1_index
2072: 1994 00014384 81 03 13 fe6d jlss L448
2073: 1995 00014389 L9993:
2074: 1996 00014389 L446:
2075: 1997 00014389 # } while( index++ < max_cmpf_1_index );
2076: 1998 00014389 L444:
2077: 1999 00014389 0d efffffecb5 50 movl _index,r0
2078: 2000 00014390 6d efffffecae incl _index
2079: 2001 00014396 1d 50 efffffeca7 cmpl r0,_max_cmpf_1_index
2080: 2002 0001439D 81 03 13 fe28 jlss L445
2081: 2003 000143A2 L443:
2082: 2004 000143A2 # } /* end of subtest 8 */
2083: 2005 000143A2 40 ret#2
2084: 2006 000143A3 .set L439,0x0
2085: 2007 000143A3 L441:
2086: 2008 000143A3 13 fe11 jbr L442
2087: 2009 000143A6 .data
2088: 2010 00001458 * .text
2089: 2011 000143A6 .align 1
2090: 2012 000143A6 .globl _print_cmpf2_data
2091: 2013 000143A6 _print_cmpf2_data:
2092: 2014 000143A6 0000 .word L462
2093: 2015 000143A8 #
2094: 2016 000143A8 #
2095: 2017 000143A8 #
2096: 2018 000143A8 # /**************************************************************************
2097: 2019 000143A8 # *
2098: 2020 000143A8 # * PRINT THE DATA AND STORE RESULTS
2099: 2021 000143A8 # *
2100: 2022 000143A8 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
2101: 2023 000143A8 # * operand = xxxxxxxx, expected = xxxxxxxx
2102: 2024 000143A8 # **************************************************************************/
2103: 2025 000143A8 # print_cmpf2_data()
2104: 2026 000143A8 # {
2105: 2027 000143A8 11 35 jbr L464
2106: 2028 000143AA L465:
2107: 2029 000143AA # writes(" initial Acc = ");
2108: 2030 000143AA .data 1
2109: 2031 00001957 * L466:
2110: 2032 00001957 * 20696E697469616C204163632 .ascii " initial Acc = \0"
2111: 03D2000
2112: 2033 00001967 * .text
2113: 2034 000143AA dd 8f00001957 pushl $L466
2114: 2035 000143B0 fe 08 efffffec8d callf $8,_writes
2115: 2036 000143B7 # write32h( sgl_ld_acc );
2116: 2037 000143B7 dd efffffec87 pushl _sgl_ld_acc
2117: 2038 000143BD fe 08 efffffec80 callf $8,_write32h
2118: 2039 000143C4 # writes(", operand 1 = ");
2119: 2040 000143C4 .data 1
2120: 2041 00001967 * L467:
2121: 2042 00001967 * 2C20206F706572616E6420312 .ascii ", operand 1 = \0"
2122: 03D2000
2123: 2043 00001977 * .text
2124: 2044 000143C4 dd 8f00001967 pushl $L467
2125: 2045 000143CA fe 08 efffffec73 callf $8,_writes
2126: 2046 000143D1 # write32h( sgl_value_1 );
2127: 2047 000143D1 dd efffffec6d pushl _sgl_value_1
2128: 2048 000143D7 fe 08 efffffec66 callf $8,_write32h
2129: 2049 000143DE # }
2130: 2050 000143DE 40 ret#2
2131: 2051 000143DF .set L462,0x0
2132: 2052 000143DF L464:
2133: 2053 000143DF 11 c9 jbr L465
2134: 2054 000143E1 .data
2135: 2055 00001458 * .text
2136: 2056 000143E1 00 .align 1
2137: 2057 000143E2 .globl _cmpf2_er_halt
2138: 2058 000143E2 _cmpf2_er_halt:
2139: 2059 000143E2 0000 .word L468
2140: 2060 000143E4 #
2141: 2061 000143E4 #
2142: 2062 000143E4 #
2143: 2063 000143E4 # /**************************************************************************
2144: 2064 000143E4 # *
2145: 2065 000143E4 # * HALT ON ERROR ROUTINE
2146: 2066 000143E4 # *
2147: 2067 000143E4 # **************************************************************************/
2148: 2068 000143E4 # cmpf2_er_halt( halt_code )
2149: 2069 000143E4 # int halt_code;
2150: 2070 000143E4 # {
2151: 2071 000143E4 13 00af jbr L470
2152: 2072 000143E7 L471:
2153: 2073 000143E7 # sgl_dummy1 = halt_code; /* get the error type */
2154: 2074 000143E7 0d ad04 efffffec55 movl 4(fp),_sgl_dummy1
2155: 2075 000143EF # asm("movl _test_no,r0"); /* r0 = test number */
2156: 2076 000143EF 0d efffffec4f 50 movl _test_no,r0
2157: 2077 000143F6 # asm("movl _subtest,r1"); /* r1 = subtest number */
2158: 2078 000143F6 0d efffffec48 51 movl _subtest,r1
2159: 2079 000143FD # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
2160: 2080 000143FD 0d efffffec41 52 movl _sgl_dummy1,r2
2161: 2081 00014404 # asm("movl _cycle,r3"); /* r3 = cycle count */
2162: 2082 00014404 0d efffffec3a 53 movl _cycle,r3
2163: 2083 0001440B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
2164: 2084 0001440B 0d efffffec33 54 movl _sgl_ld_acc,r4
2165: 2085 00014412 # asm("movl _sgl_value_1,r5"); /* r5 = operand 1 */
2166: 2086 00014412 0d efffffec2c 55 movl _sgl_value_1,r5
2167: 2087 00014419 # asm("movl _sgl_value_2,r6"); /* r6 = operand 2 */
2168: 2088 00014419 0d efffffec25 56 movl _sgl_value_2,r6
2169: 2089 00014420 # asm("movl _psl_val,r7"); /* r7 = actual PSL */
2170: 2090 00014420 0d efffffec1e 57 movl _psl_val,r7
2171: 2091 00014427 # if( halt_code == BAD_ACC_HLT ) {
2172: 2092 00014427 1d ad04 01 cmpl 4(fp),$1
2173: 2093 0001442B 21 10 jneq L472
2174: 2094 0001442D # asm("movl _sgl_st_acc,r8"); /* r8 = actual value */
2175: 2095 0001442D 0d efffffec11 58 movl _sgl_st_acc,r8
2176: 2096 00014434 # asm("movl _sgl_expected,r9"); /* r9 = expected value */
2177: 2097 00014434 0d efffffec0a 59 movl _sgl_expected,r9
2178: 2098 0001443B # } else
2179: 2099 0001443B 11 57 jbr L473
2180: 2100 0001443D L472:
2181: 2101 0001443D # if( halt_code == BAD_REG_HLT ) {
2182: 2102 0001443D 1d ad04 02 cmpl 4(fp),$2
2183: 2103 00014441 21 3d jneq L474
2184: 2104 00014443 # sgl_dummy1 = load_regs[index2];
2185: 2105 00014443 0d efffffebfb 50 movl _index2,r0
2186: 2106 0001444A 0d 40efffffebf3 movl _load_regs[r0],_sgl_dummy1
2187: efffffebee
2188: 2107 00014456 # sgl_dummy2 = store_regs[index2];
2189: 2108 00014456 0d efffffebe8 50 movl _index2,r0
2190: 2109 0001445D 0d 40efffffebe0 movl _store_regs[r0],_sgl_dummy2
2191: efffffebdb
2192: 2110 00014469 # asm("movl _index2,r8"); /* r8 = bad register # */
2193: 2111 00014469 0d efffffebd5 58 movl _index2,r8
2194: 2112 00014470 # asm("movl _sgl_dummy2,r9"); /* r9 = actual value */
2195: 2113 00014470 0d efffffebce 59 movl _sgl_dummy2,r9
2196: 2114 00014477 # asm("movl _sgl_dummy1,r10"); /* r10 = expected value */
2197: 2115 00014477 0d efffffebc7 5a movl _sgl_dummy1,r10
2198: 2116 0001447E # } else
2199: 2117 0001447E 11 14 jbr L475
2200: 2118 00014480 L474:
2201: 2119 00014480 # if( halt_code == BAD_PSL_HLT ) {
2202: 2120 00014480 1d ad04 03 cmpl 4(fp),$3
2203: 2121 00014484 21 0e jneq L476
2204: 2122 00014486 # asm("movl _exp_psl,r7"); /* r8 = expected PSL */
2205: 2123 00014486 0d efffffebb8 57 movl _exp_psl,r7
2206: 2124 0001448D # asm("movl _index,r9"); /* r9 = data index */
2207: 2125 0001448D 0d efffffebb1 59 movl _index,r9
2208: 2126 00014494 # };
2209: 2127 00014494 L476:
2210: 2128 00014494 L475:
2211: 2129 00014494 L473:
2212: 2130 00014494 # asm("halt"); /* HALT ... */
2213: 2131 00014494 00 halt
2214: 2132 00014495 # }
2215: 2133 00014495 40 ret#2
2216: 2134 00014496 .set L468,0x0
2217: 2135 00014496 L470:
2218: 2136 00014496 13 ff4e jbr L471
2219: 2137 00014499 .data
2220: 2137 000274DD .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.