![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf.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 cmpf.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 00000c8c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _cmpf
6: 6 00000000 _cmpf:
7: 7 000123B8 0000 .word L215
8: 8 000123BA # #include "fpp_defs.h"
9: 9 000123BA #
10: 10 000123BA #
11: 11 000123BA #
12: 12 000123BA # /***************************************************************************
13: 13 000123BA # *
14: 14 000123BA # * CMPF -COMPARE SGL ACCUMULATOR TO SGL OPERAND
15: 15 000123BA # *
16: 16 000123BA # *****************************************************************************/
17: 17 000123BA # cmpf()
18: 18 000123BA # {
19: 19 000123BA 11 57 jbr L217
20: 20 000123BC L218:
21: 21 000123BC # asm(".globl _cmpf_t");
22: 22 000123BC .globl _cmpf_t
23: 23 000123BC # asm("_cmpf_t:"); /* entry address */
24: 24 000123BC _cmpf_t:
25: 25 000123BC # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26: 26 000123BC 1d effffffff6 01 cmpl _cycle,$1
27: 27 000123C3 21 15 jneq L219
28: 28 000123C5 5d efffffffed tstl _prt_hdrs
29: 29 000123CB 31 0d jeql L219
30: 30 000123CD # {
31: 31 000123CD # writes(" CMPF");
32: 32 000123CD .data 1
33: 33 00000c8c * L221:
34: 34 00000c8c * 20434D504600 .ascii " CMPF\0"
35: 35 00000c92 * .text
36: 36 000123CD dd 8f00000c8c pushl $L221
37: 37 000123D3 fe 08 efffffffde callf $8,_writes
38: 38 000123DA # }
39: 39 000123DA # cmpf_1(); /* test via registers */
40: 40 000123DA L219:
41: 41 000123DA fe 04 ef00000035 callf $4,_cmpf_1
42: 42 000123E1 # cmpf_2(); /* test via cache */
43: 43 000123E1 fe 04 ef00000248 callf $4,_cmpf_2
44: 44 000123E8 # cmpf_3(); /* register corruption test */
45: 45 000123E8 fe 04 ef00000455 callf $4,_cmpf_3
46: 46 000123EF # cmpf_4(); /* acc. corruption test */
47: 47 000123EF fe 04 ef00000628 callf $4,_cmpf_4
48: 48 000123F6 # if( !no_fpp_wcs ) {
49: 49 000123F6 5d efffffffbc tstl _no_fpp_wcs
50: 50 000123FC 21 0e jneq L226
51: 51 000123FE # cmpf_5(); /* pipelined entry test */
52: 52 000123FE fe 04 ef000007a3 callf $4,_cmpf_5
53: 53 00012405 # cmpf_6(); /* pipelined exit test */
54: 54 00012405 fe 04 ef000009b6 callf $4,_cmpf_6
55: 55 0001240C # };
56: 56 0001240C L226:
57: 57 0001240C # asm("jmp *return"); /* return to the test monitor */
58: 58 0001240C 71 ffffffffa6 jmp *return
59: 59 00012412 # }
60: 60 00012412 40 ret#2
61: 61 00012413 .set L215,0x0
62: 62 00012413 L217:
63: 63 00012413 11 a7 jbr L218
64: 64 00012415 .data
65: 65 00000c8c * .text
66: 66 00012415 00 .align 1
67: 67 00012416 .globl _cmpf_1
68: 68 00012416 _cmpf_1:
69: 69 00012416 0000 .word L229
70: 70 00012418 #
71: 71 00012418 #
72: 72 00012418 #
73: 73 00012418 # /****************************************************************************
74: 74 00012418 # *
75: 75 00012418 # * SUBTEST 1 - CMPF status test -register data
76: 76 00012418 # *
77: 77 00012418 # ****************************************************************************/
78: 78 00012418 # cmpf_1()
79: 79 00012418 # {
80: 80 00012418 13 0212 jbr L231
81: 81 0001241B L232:
82: 82 0001241B # force_loop = FALSE;
83: 83 0001241B 4d efffffff97 clrl _force_loop
84: 84 00012421 # subtest = 1;
85: 85 00012421 0d 01 efffffff90 movl $1,_subtest
86: 86 00012428 # index = 0;
87: 87 00012428 4d efffffff8a clrl _index
88: 88 0001242E # do
89: 89 0001242E L235:
90: 90 0001242E # {
91: 91 0001242E # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
92: 92 0001242E 5c 0c efffffff83 50 mull3 $12,_index,r0
93: 93 00012436 0d e000000000 efffffff77 movl _cmpf_1_data(r0),_sgl_value_1
94: 94 00012441 # sgl_value_2 = cmpf_1_data[index].two;
95: 95 00012441 5c 0c efffffff70 50 mull3 $12,_index,r0
96: 96 00012449 0d e000000004 efffffff64 movl _cmpf_1_data+4(r0),_sgl_value_2
97: 97 00012454 # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
98: 98 00012454 5c 0c efffffff5d 50 mull3 $12,_index,r0
99: 99 0001245C 0d e000000008 efffffff51 movl _cmpf_1_data+8(r0),_sgl_expected
100: 100 00012467 # status_index = 0; /* clear the status index */
101: 101 00012467 4d efffffff4b clrl _status_index
102: 102 0001246D # do
103: 103 0001246D L238:
104: 104 0001246D # {
105: 105 0001246D # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
106: 106 0001246D 0d efffffff45 50 movl _status_index,r0
107: 107 00012474 0d 40efffffff3d movl _status_array[r0],_sgl_dummy1
108: efffffff38
109: 108 00012480 # /*
110: 109 00012480 # * If LOOP ON ERROR is set, this is the loop for this subtest.
111: 110 00012480 # * The force loop flag is set after the first error.
112: 111 00012480 # */
113: 112 00012480 # asm("_cmpf_1_lp1:");
114: 113 00012480 _cmpf_1_lp1:
115: 114 00012480 # asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
116: 115 00012480 0d efffffff32 54 movl _sgl_value_1,r4
117: 116 00012487 # asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
118: 117 00012487 0d efffffff2b 55 movl _sgl_value_2,r5
119: 118 0001248E # asm("ldf r4"); /* load the 1st operand */
120: 119 0001248E 06 54 ldf r4
121: 120 00012490 # asm("tstl _sgl_dummy1"); /* generate initial status */
122: 121 00012490 5d efffffff22 tstl _sgl_dummy1
123: 122 00012496 # asm("movpsl _init_psl"); /* save the initial status */
124: 123 00012496 cd efffffff1c movpsl _init_psl
125: 124 0001249C # asm("cmpf r5"); /* compare the operands */
126: 125 0001249C 36 55 cmpf r5
127: 126 0001249E # asm("movpsl _psl_val"); /* save the final status */
128: 127 0001249E cd efffffff14 movpsl _psl_val
129: 128 000124A4 # asm("stf _sgl_st_acc"); /* save the final acc */
130: 129 000124A4 26 efffffff0e stf _sgl_st_acc
131: 130 000124AA # if( force_loop ) /* loop? */
132: 131 000124AA 5d efffffff08 tstl _force_loop
133: 132 000124B0 31 02 jeql L239
134: 133 000124B2 # asm("brb _cmpf_1_lp1");; /* run the loop again */
135: 134 000124B2 11 cc brb _cmpf_1_lp1
136: 135 000124B4 L239:
137: 136 000124B4 # exp_psl = init_psl; /* get the initial PSL */
138: 137 000124B4 0d effffffefe effffffef9 movl _init_psl,_exp_psl
139: 138 000124BF # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
140: 139 000124BF ac 88f3 effffffef1 andl2 $-13,_exp_psl
141: 140 000124C7 # if( sgl_expected == ZERO )
142: 141 000124C7 1d effffffeeb 04 cmpl _sgl_expected,$4
143: 142 000124CE 21 07 jneq L240
144: 143 000124D0 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
145: 144 000124D0 8c 04 effffffee1 orl2 $4,_exp_psl
146: 145 000124D7 # if( sgl_expected == NEGATIVE )
147: 146 000124D7 L240:
148: 147 000124D7 1d effffffedb 08 cmpl _sgl_expected,$8
149: 148 000124DE 21 07 jneq L241
150: 149 000124E0 # exp_psl |= PSL_N; /* expect the NEG bit set */
151: 150 000124E0 8c 08 effffffed1 orl2 $8,_exp_psl
152: 151 000124E7 # if( psl_val != exp_psl ) { /* COMPARE the values */
153: 152 000124E7 L241:
154: 153 000124E7 1d effffffecb effffffec6 cmpl _psl_val,_exp_psl
155: 154 000124F2 21 03 13 0107 jeql L242
156: 155 000124F7 # errcnt++; /* bump the error count */
157: 156 000124F7 6d effffffebb incl _errcnt
158: 157 000124FD # if ( prt_error ) {
159: 158 000124FD 5d effffffeb5 tstl _prt_error
160: 159 00012503 21 03 13 00d3 jeql L243
161: 160 00012508 # writes(" \n"); /* start a new print line */
162: 161 00012508 .data 1
163: 162 00000c92 * L244:
164: 163 00000c92 * 200A00 .ascii " \12\0"
165: 164 00000c95 * .text
166: 165 00012508 dd 8f00000c92 pushl $L244
167: 166 0001250E fe 08 effffffea3 callf $8,_writes
168: 167 00012515 # writes("cycle: ");
169: 168 00012515 .data 1
170: 169 00000c95 * L245:
171: 170 00000c95 * 6379636C653A2000 .ascii "cycle: \0"
172: 171 00000c9d * .text
173: 172 00012515 dd 8f00000c95 pushl $L245
174: 173 0001251B fe 08 effffffe96 callf $8,_writes
175: 174 00012522 # writed( cycle );
176: 175 00012522 dd effffffe90 pushl _cycle
177: 176 00012528 fe 08 effffffe89 callf $8,_writed
178: 177 0001252F # writes(" CMPF test ");
179: 178 0001252F .data 1
180: 179 00000c9d * L247:
181: 180 00000c9d * 2020434D50462074657374200 .ascii " CMPF test \0"
182: 0
183: 181 00000caa * .text
184: 182 0001252F dd 8f00000c9d pushl $L247
185: 183 00012535 fe 08 effffffe7c callf $8,_writes
186: 184 0001253C # writed( test_no );
187: 185 0001253C dd effffffe76 pushl _test_no
188: 186 00012542 fe 08 effffffe6f callf $8,_writed
189: 187 00012549 # writes(", subtest 1 (Reg. Data) - BAD FINAL PSL\n");
190: 188 00012549 .data 1
191: 189 00000caa * L248:
192: 190 00000caa * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL PSL\12\0"
193: 85265672E204461746129202D
194: 204241442046494E414C20505
195: 34C0A00
196: 191 00000cd3 * .text
197: 192 00012549 dd 8f00000caa pushl $L248
198: 193 0001254F fe 08 effffffe62 callf $8,_writes
199: 194 00012556 # print_cmpf_data();
200: 195 00012556 fe 04 ef000009fb callf $4,_print_cmpf_data
201: 196 0001255D # writes(", data index = ");
202: 197 0001255D .data 1
203: 198 00000cd3 * L250:
204: 199 00000cd3 * 2C20206461746120696E64657 .ascii ", data index = \0"
205: 8203D2000
206: 200 00000ce4 * .text
207: 201 0001255D dd 8f00000cd3 pushl $L250
208: 202 00012563 fe 08 effffffe4e callf $8,_writes
209: 203 0001256A # writed( index );
210: 204 0001256A dd effffffe48 pushl _index
211: 205 00012570 fe 08 effffffe41 callf $8,_writed
212: 206 00012577 # writec('\n');
213: 207 00012577 dd 0a pushl $10
214: 208 00012579 fe 08 effffffe38 callf $8,_writec
215: 209 00012580 # writes("initial PSL = ");
216: 210 00012580 .data 1
217: 211 00000ce4 * L252:
218: 212 00000ce4 * 696E697469616C2050534C203 .ascii "initial PSL = \0"
219: D2000
220: 213 00000cf3 * .text
221: 214 00012580 dd 8f00000ce4 pushl $L252
222: 215 00012586 fe 08 effffffe2b callf $8,_writes
223: 216 0001258D # write32h( init_psl );
224: 217 0001258D dd effffffe25 pushl _init_psl
225: 218 00012593 fe 08 effffffe1e callf $8,_write32h
226: 219 0001259A # writes(", final PSL = ");
227: 220 0001259A .data 1
228: 221 00000cf3 * L254:
229: 222 00000cf3 * 2C2066696E616C2050534C203 .ascii ", final PSL = \0"
230: D2000
231: 223 00000d02 * .text
232: 224 0001259A dd 8f00000cf3 pushl $L254
233: 225 000125A0 fe 08 effffffe11 callf $8,_writes
234: 226 000125A7 # write32h( psl_val );
235: 227 000125A7 dd effffffe0b pushl _psl_val
236: 228 000125AD fe 08 effffffe04 callf $8,_write32h
237: 229 000125B4 # writes(", expected PSL = ");
238: 230 000125B4 .data 1
239: 231 00000d02 * L255:
240: 232 00000d02 * 2C20657870656374656420505 .ascii ", expected PSL = \0"
241: 34C203D2000
242: 233 00000d14 * .text
243: 234 000125B4 dd 8f00000d02 pushl $L255
244: 235 000125BA fe 08 effffffdf7 callf $8,_writes
245: 236 000125C1 # write32h( exp_psl );
246: 237 000125C1 dd effffffdf1 pushl _exp_psl
247: 238 000125C7 fe 08 effffffdea callf $8,_write32h
248: 239 000125CE # writes("\n");
249: 240 000125CE .data 1
250: 241 00000d14 * L256:
251: 242 00000d14 * 0A00 .ascii "\12\0"
252: 243 00000d16 * .text
253: 244 000125CE dd 8f00000d14 pushl $L256
254: 245 000125D4 fe 08 effffffddd callf $8,_writes
255: 246 000125DB # }
256: 247 000125DB # if ( halt_flg )
257: 248 000125DB L243:
258: 249 000125DB 5d effffffdd7 tstl _halt_flg
259: 250 000125E1 31 09 jeql L257
260: 251 000125E3 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
261: 252 000125E3 dd 03 pushl $3
262: 253 000125E5 fe 08 ef000009a8 callf $8,_cmpf_er_halt
263: 254 000125EC # if ( loop_on_err ) {
264: 255 000125EC L257:
265: 256 000125EC 5d effffffdc6 tstl _loop_on_err
266: 257 000125F2 31 0a jeql L259
267: 258 000125F4 # force_loop = TRUE; /* set the force loop flag */
268: 259 000125F4 0d 01 effffffdbd movl $1,_force_loop
269: 260 000125FB # asm("brw _cmpf_1_lp1"); /* and loop on the error */
270: 261 000125FB 13 fe82 brw _cmpf_1_lp1
271: 262 000125FE # } /* end of loop on error */
272: 263 000125FE # } /* end of compare error */
273: 264 000125FE L259:
274: 265 000125FE # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
275: 266 000125FE L242:
276: 267 000125FE L237:
277: 268 000125FE 6d effffffdb4 incl _status_index
278: 269 00012604 0d effffffdae 50 movl _status_index,r0
279: 270 0001260B 1d 50 03 cmpl r0,$3
280: 271 0001260E 81 03 13 fe5a jlss L238
281: 272 00012613 L236:
282: 273 00012613 # } while( index++ < max_cmpf_1_index);/* end of data loop */
283: 274 00012613 L234:
284: 275 00012613 0d effffffd9f 50 movl _index,r0
285: 276 0001261A 6d effffffd98 incl _index
286: 277 00012620 1d 50 effffffd91 cmpl r0,_max_cmpf_1_index
287: 278 00012627 81 03 13 fe02 jlss L235
288: 279 0001262C L233:
289: 280 0001262C # } /* end of subtest 1 */
290: 281 0001262C 40 ret#2
291: 282 0001262D .set L229,0x0
292: 283 0001262D L231:
293: 284 0001262D 13 fdeb jbr L232
294: 285 00012630 .data
295: 286 00000c8c * .text
296: 287 00012630 .align 1
297: 288 00012630 .globl _cmpf_2
298: 289 00012630 _cmpf_2:
299: 290 00012630 0000 .word L260
300: 291 00012632 #
301: 292 00012632 #
302: 293 00012632 #
303: 294 00012632 # /****************************************************************************
304: 295 00012632 # *
305: 296 00012632 # * SUBTEST 2 - CMPF status test -cache data
306: 297 00012632 # *
307: 298 00012632 # ****************************************************************************/
308: 299 00012632 # cmpf_2()
309: 300 00012632 # {
310: 301 00012632 13 020c jbr L262
311: 302 00012635 L263:
312: 303 00012635 # force_loop = FALSE;
313: 304 00012635 4d effffffd7d clrl _force_loop
314: 305 0001263B # subtest = 2;
315: 306 0001263B 0d 02 effffffd76 movl $2,_subtest
316: 307 00012642 # index = 0;
317: 308 00012642 4d effffffd70 clrl _index
318: 309 00012648 # do
319: 310 00012648 L266:
320: 311 00012648 # {
321: 312 00012648 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
322: 313 00012648 5c 0c effffffd69 50 mull3 $12,_index,r0
323: 314 00012650 0d e000000000 effffffd5d movl _cmpf_1_data(r0),_sgl_value_1
324: 315 0001265B # sgl_value_2 = cmpf_1_data[index].two;
325: 316 0001265B 5c 0c effffffd56 50 mull3 $12,_index,r0
326: 317 00012663 0d e000000004 effffffd4a movl _cmpf_1_data+4(r0),_sgl_value_2
327: 318 0001266E # sgl_expected = cmpf_1_data[index].flag;/* get expected results */
328: 319 0001266E 5c 0c effffffd43 50 mull3 $12,_index,r0
329: 320 00012676 0d e000000008 effffffd37 movl _cmpf_1_data+8(r0),_sgl_expected
330: 321 00012681 # status_index = 0; /* clear the status index */
331: 322 00012681 4d effffffd31 clrl _status_index
332: 323 00012687 # do
333: 324 00012687 L269:
334: 325 00012687 # {
335: 326 00012687 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
336: 327 00012687 0d effffffd2b 50 movl _status_index,r0
337: 328 0001268E 0d 40effffffd23 movl _status_array[r0],_sgl_dummy1
338: effffffd1e
339: 329 0001269A # /*
340: 330 0001269A # * If LOOP ON ERROR is set, this is the loop for this subtest.
341: 331 0001269A # * The force loop flag is set after the first error.
342: 332 0001269A # */
343: 333 0001269A # asm("_cmpf_2_lp1:");
344: 334 0001269A _cmpf_2_lp1:
345: 335 0001269A # asm("ldf _sgl_value_1"); /* load the 1st operand */
346: 336 0001269A 06 effffffd18 ldf _sgl_value_1
347: 337 000126A0 # asm("tstl _sgl_dummy1"); /* generate initial status */
348: 338 000126A0 5d effffffd12 tstl _sgl_dummy1
349: 339 000126A6 # asm("movpsl _init_psl"); /* save the initial status */
350: 340 000126A6 cd effffffd0c movpsl _init_psl
351: 341 000126AC # asm("cmpf _sgl_value_2"); /* compare the operands */
352: 342 000126AC 36 effffffd06 cmpf _sgl_value_2
353: 343 000126B2 # asm("movpsl _psl_val"); /* save the final status */
354: 344 000126B2 cd effffffd00 movpsl _psl_val
355: 345 000126B8 # asm("stf _sgl_st_acc"); /* save the final acc */
356: 346 000126B8 26 effffffcfa stf _sgl_st_acc
357: 347 000126BE # if( force_loop ) /* loop? */
358: 348 000126BE 5d effffffcf4 tstl _force_loop
359: 349 000126C4 31 02 jeql L270
360: 350 000126C6 # asm("brb _cmpf_2_lp1");; /* run the loop again */
361: 351 000126C6 11 d2 brb _cmpf_2_lp1
362: 352 000126C8 L270:
363: 353 000126C8 # exp_psl = init_psl; /* get the initial PSL */
364: 354 000126C8 0d effffffcea effffffce5 movl _init_psl,_exp_psl
365: 355 000126D3 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
366: 356 000126D3 ac 88f3 effffffcdd andl2 $-13,_exp_psl
367: 357 000126DB # if( sgl_expected == ZERO )
368: 358 000126DB 1d effffffcd7 04 cmpl _sgl_expected,$4
369: 359 000126E2 21 07 jneq L271
370: 360 000126E4 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
371: 361 000126E4 8c 04 effffffccd orl2 $4,_exp_psl
372: 362 000126EB # if( sgl_expected == NEGATIVE )
373: 363 000126EB L271:
374: 364 000126EB 1d effffffcc7 08 cmpl _sgl_expected,$8
375: 365 000126F2 21 07 jneq L272
376: 366 000126F4 # exp_psl |= PSL_N; /* expect the NEG bit set */
377: 367 000126F4 8c 08 effffffcbd orl2 $8,_exp_psl
378: 368 000126FB # if( psl_val != exp_psl ) { /* COMPARE the values */
379: 369 000126FB L272:
380: 370 000126FB 1d effffffcb7 effffffcb2 cmpl _psl_val,_exp_psl
381: 371 00012706 21 03 13 0107 jeql L273
382: 372 0001270B # errcnt++; /* bump the error count */
383: 373 0001270B 6d effffffca7 incl _errcnt
384: 374 00012711 # if ( prt_error ) {
385: 375 00012711 5d effffffca1 tstl _prt_error
386: 376 00012717 21 03 13 00d3 jeql L274
387: 377 0001271C # writes(" \n"); /* start a new print line */
388: 378 0001271C .data 1
389: 379 00000d16 * L275:
390: 380 00000d16 * 200A00 .ascii " \12\0"
391: 381 00000d19 * .text
392: 382 0001271C dd 8f00000d16 pushl $L275
393: 383 00012722 fe 08 effffffc8f callf $8,_writes
394: 384 00012729 # writes("cycle: ");
395: 385 00012729 .data 1
396: 386 00000d19 * L276:
397: 387 00000d19 * 6379636C653A2000 .ascii "cycle: \0"
398: 388 00000d21 * .text
399: 389 00012729 dd 8f00000d19 pushl $L276
400: 390 0001272F fe 08 effffffc82 callf $8,_writes
401: 391 00012736 # writed( cycle );
402: 392 00012736 dd effffffc7c pushl _cycle
403: 393 0001273C fe 08 effffffc75 callf $8,_writed
404: 394 00012743 # writes(" CMPF test ");
405: 395 00012743 .data 1
406: 396 00000d21 * L277:
407: 397 00000d21 * 2020434D50462074657374200 .ascii " CMPF test \0"
408: 0
409: 398 00000d2e * .text
410: 399 00012743 dd 8f00000d21 pushl $L277
411: 400 00012749 fe 08 effffffc68 callf $8,_writes
412: 401 00012750 # writed( test_no );
413: 402 00012750 dd effffffc62 pushl _test_no
414: 403 00012756 fe 08 effffffc5b callf $8,_writed
415: 404 0001275D # writes(", subtest 2 (Cache Data) - BAD FINAL PSL\n");
416: 405 0001275D .data 1
417: 406 00000d2e * L278:
418: 407 00000d2e * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL PSL\12\0"
419: 8436163686520446174612920
420: 2D204241442046494E414C205
421: 0534C0A00
422: 408 00000d58 * .text
423: 409 0001275D dd 8f00000d2e pushl $L278
424: 410 00012763 fe 08 effffffc4e callf $8,_writes
425: 411 0001276A # print_cmpf_data();
426: 412 0001276A fe 04 ef000007e7 callf $4,_print_cmpf_data
427: 413 00012771 # writes(", data index = ");
428: 414 00012771 .data 1
429: 415 00000d58 * L279:
430: 416 00000d58 * 2C20206461746120696E64657 .ascii ", data index = \0"
431: 8203D2000
432: 417 00000d69 * .text
433: 418 00012771 dd 8f00000d58 pushl $L279
434: 419 00012777 fe 08 effffffc3a callf $8,_writes
435: 420 0001277E # writed( index );
436: 421 0001277E dd effffffc34 pushl _index
437: 422 00012784 fe 08 effffffc2d callf $8,_writed
438: 423 0001278B # writec('\n');
439: 424 0001278B dd 0a pushl $10
440: 425 0001278D fe 08 effffffc24 callf $8,_writec
441: 426 00012794 # writes("initial PSL = ");
442: 427 00012794 .data 1
443: 428 00000d69 * L280:
444: 429 00000d69 * 696E697469616C2050534C203 .ascii "initial PSL = \0"
445: D2000
446: 430 00000d78 * .text
447: 431 00012794 dd 8f00000d69 pushl $L280
448: 432 0001279A fe 08 effffffc17 callf $8,_writes
449: 433 000127A1 # write32h( init_psl );
450: 434 000127A1 dd effffffc11 pushl _init_psl
451: 435 000127A7 fe 08 effffffc0a callf $8,_write32h
452: 436 000127AE # writes(", final PSL = ");
453: 437 000127AE .data 1
454: 438 00000d78 * L281:
455: 439 00000d78 * 2C2066696E616C2050534C203 .ascii ", final PSL = \0"
456: D2000
457: 440 00000d87 * .text
458: 441 000127AE dd 8f00000d78 pushl $L281
459: 442 000127B4 fe 08 effffffbfd callf $8,_writes
460: 443 000127BB # write32h( psl_val );
461: 444 000127BB dd effffffbf7 pushl _psl_val
462: 445 000127C1 fe 08 effffffbf0 callf $8,_write32h
463: 446 000127C8 # writes(", expected PSL = ");
464: 447 000127C8 .data 1
465: 448 00000d87 * L282:
466: 449 00000d87 * 2C20657870656374656420505 .ascii ", expected PSL = \0"
467: 34C203D2000
468: 450 00000d99 * .text
469: 451 000127C8 dd 8f00000d87 pushl $L282
470: 452 000127CE fe 08 effffffbe3 callf $8,_writes
471: 453 000127D5 # write32h( exp_psl );
472: 454 000127D5 dd effffffbdd pushl _exp_psl
473: 455 000127DB fe 08 effffffbd6 callf $8,_write32h
474: 456 000127E2 # writes("\n");
475: 457 000127E2 .data 1
476: 458 00000d99 * L283:
477: 459 00000d99 * 0A00 .ascii "\12\0"
478: 460 00000d9b * .text
479: 461 000127E2 dd 8f00000d99 pushl $L283
480: 462 000127E8 fe 08 effffffbc9 callf $8,_writes
481: 463 000127EF # }
482: 464 000127EF # if ( halt_flg )
483: 465 000127EF L274:
484: 466 000127EF 5d effffffbc3 tstl _halt_flg
485: 467 000127F5 31 09 jeql L284
486: 468 000127F7 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
487: 469 000127F7 dd 03 pushl $3
488: 470 000127F9 fe 08 ef00000794 callf $8,_cmpf_er_halt
489: 471 00012800 # if ( loop_on_err ) {
490: 472 00012800 L284:
491: 473 00012800 5d effffffbb2 tstl _loop_on_err
492: 474 00012806 31 0a jeql L285
493: 475 00012808 # force_loop = TRUE; /* set the force loop flag */
494: 476 00012808 0d 01 effffffba9 movl $1,_force_loop
495: 477 0001280F # asm("brw _cmpf_2_lp1"); /* and loop on the error */
496: 478 0001280F 13 fe88 brw _cmpf_2_lp1
497: 479 00012812 # } /* end of loop on error */
498: 480 00012812 # } /* end of compare error */
499: 481 00012812 L285:
500: 482 00012812 # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
501: 483 00012812 L273:
502: 484 00012812 L268:
503: 485 00012812 6d effffffba0 incl _status_index
504: 486 00012818 0d effffffb9a 50 movl _status_index,r0
505: 487 0001281F 1d 50 03 cmpl r0,$3
506: 488 00012822 81 03 13 fe60 jlss L269
507: 489 00012827 L267:
508: 490 00012827 # } while( index++ < max_cmpf_1_index);/* end of data loop */
509: 491 00012827 L265:
510: 492 00012827 0d effffffb8b 50 movl _index,r0
511: 493 0001282E 6d effffffb84 incl _index
512: 494 00012834 1d 50 effffffb7d cmpl r0,_max_cmpf_1_index
513: 495 0001283B 81 03 13 fe08 jlss L266
514: 496 00012840 L264:
515: 497 00012840 # } /* end of subtest 2 */
516: 498 00012840 40 ret#2
517: 499 00012841 .set L260,0x0
518: 500 00012841 L262:
519: 501 00012841 13 fdf1 jbr L263
520: 502 00012844 .data
521: 503 00000c8c * .text
522: 504 00012844 .align 1
523: 505 00012844 .globl _cmpf_3
524: 506 00012844 _cmpf_3:
525: 507 00012844 0000 .word L286
526: 508 00012846 #
527: 509 00012846 #
528: 510 00012846 #
529: 511 00012846 # /************************************************************************
530: 512 00012846 # *
531: 513 00012846 # * SUBTEST 3 - Check for register corruption
532: 514 00012846 # *
533: 515 00012846 # ************************************************************************/
534: 516 00012846 # cmpf_3()
535: 517 00012846 # {
536: 518 00012846 13 01d2 jbr L288
537: 519 00012849 L289:
538: 520 00012849 # force_loop = FALSE; /* clear force_loop flg */
539: 521 00012849 4d effffffb69 clrl _force_loop
540: 522 0001284F # subtest = 3;
541: 523 0001284F 0d 03 effffffb62 movl $3,_subtest
542: 524 00012856 # fill_reg_buf( load_regs ); /* get pattern for regs */
543: 525 00012856 dd 8f00000000 pushl $_load_regs
544: 526 0001285C fe 08 effffffb55 callf $8,_fill_reg_buf
545: 527 00012863 # index = 0;
546: 528 00012863 4d effffffb4f clrl _index
547: 529 00012869 # do
548: 530 00012869 L293:
549: 531 00012869 # {
550: 532 00012869 # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
551: 533 00012869 5c 0c effffffb48 50 mull3 $12,_index,r0
552: 534 00012871 0d e000000000 effffffb3c movl _cmpf_1_data(r0),_sgl_value_1
553: 535 0001287C # sgl_value_2 = cmpf_1_data[index].two; /* data to compare */
554: 536 0001287C 5c 0c effffffb35 50 mull3 $12,_index,r0
555: 537 00012884 0d e000000004 effffffb29 movl _cmpf_1_data+4(r0),_sgl_value_2
556: 538 0001288F # /*
557: 539 0001288F # * If LOOP ON ERROR is set, this is the loop for this subtest.
558: 540 0001288F # * The force loop flag is set after the first error.
559: 541 0001288F # */
560: 542 0001288F # asm("_cmpf_3_lp1:");
561: 543 0001288F _cmpf_3_lp1:
562: 544 0001288F # asm("ldf _sgl_value_1"); /* LOAD the accumulator */
563: 545 0001288F 06 effffffb23 ldf _sgl_value_1
564: 546 00012895 # asm("nop");
565: 547 00012895 10 nop
566: 548 00012896 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
567: 549 00012896 ab 891fff effffffb19 loadr $0x1fff,_load_regs
568: 550 0001289F # asm("nop");
569: 551 0001289F 10 nop
570: 552 000128A0 # asm("cmpf _sgl_value_2"); /* test the values */
571: 553 000128A0 36 effffffb12 cmpf _sgl_value_2
572: 554 000128A6 # asm("nop");
573: 555 000128A6 10 nop
574: 556 000128A7 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
575: 557 000128A7 bb 891fff effffffb08 storer $0x1fff,_store_regs
576: 558 000128B0 # asm("stf _sgl_st_acc"); /* save the final acc */
577: 559 000128B0 26 effffffb02 stf _sgl_st_acc
578: 560 000128B6 # if( force_loop ) /* loop? */
579: 561 000128B6 5d effffffafc tstl _force_loop
580: 562 000128BC 31 02 jeql L294
581: 563 000128BE # asm("brb _cmpf_3_lp1");; /* run the loop again */
582: 564 000128BE 11 cf brb _cmpf_3_lp1
583: 565 000128C0 L294:
584: 566 000128C0 # /*
585: 567 000128C0 # * Now compare the stored register values to those that were loaded
586: 568 000128C0 # */
587: 569 000128C0 # index2 = 0;
588: 570 000128C0 4d effffffaf2 clrl _index2
589: 571 000128C6 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
590: 572 000128C6 L295:
591: 573 000128C6 0d effffffaec 50 movl _index2,r0
592: 574 000128CD 0d effffffae5 51 movl _index2,r1
593: 575 000128D4 1d 40effffffadd cmpl _load_regs[r0],_store_regs[r1]
594: 41effffffad7
595: 576 000128E1 21 11 jneq L296
596: 577 000128E3 1d effffffacf 0d cmpl _index2,$13
597: 578 000128EA 81 08 jgeq L296
598: 579 000128EC # index2++; /* check reg values */
599: 580 000128EC 6d effffffac6 incl _index2
600: 581 000128F2 11 d2 jbr L295
601: 582 000128F4 L296:
602: 583 000128F4 # if( index2 < 13 ) { /* error if index2 < 13 */
603: 584 000128F4 1d effffffabe 0d cmpl _index2,$13
604: 585 000128FB 91 03 13 0101 jgeq L297
605: 586 00012900 # errcnt++; /* bump the error count */
606: 587 00012900 6d effffffab2 incl _errcnt
607: 588 00012906 # if ( prt_error ) {
608: 589 00012906 5d effffffaac tstl _prt_error
609: 590 0001290C 21 03 13 00cd jeql L298
610: 591 00012911 # writes(" \n"); /* start a new print line */
611: 592 00012911 .data 1
612: 593 00000d9b * L299:
613: 594 00000d9b * 200A00 .ascii " \12\0"
614: 595 00000d9e * .text
615: 596 00012911 dd 8f00000d9b pushl $L299
616: 597 00012917 fe 08 effffffa9a callf $8,_writes
617: 598 0001291E # writes("cycle: ");
618: 599 0001291E .data 1
619: 600 00000d9e * L300:
620: 601 00000d9e * 6379636C653A2000 .ascii "cycle: \0"
621: 602 00000da6 * .text
622: 603 0001291E dd 8f00000d9e pushl $L300
623: 604 00012924 fe 08 effffffa8d callf $8,_writes
624: 605 0001292B # writed( cycle );
625: 606 0001292B dd effffffa87 pushl _cycle
626: 607 00012931 fe 08 effffffa80 callf $8,_writed
627: 608 00012938 # writes(", CMPF test ");
628: 609 00012938 .data 1
629: 610 00000da6 * L301:
630: 611 00000da6 * 2C20434D50462074657374200 .ascii ", CMPF test \0"
631: 0
632: 612 00000db3 * .text
633: 613 00012938 dd 8f00000da6 pushl $L301
634: 614 0001293E fe 08 effffffa73 callf $8,_writes
635: 615 00012945 # writed( test_no );
636: 616 00012945 dd effffffa6d pushl _test_no
637: 617 0001294B fe 08 effffffa66 callf $8,_writed
638: 618 00012952 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n");
639: 619 00012952 .data 1
640: 620 00000db3 * L302:
641: 621 00000db3 * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0"
642: D204120524547495354455220
643: 574153204D4F4449464945440
644: A00
645: 622 00000dda * .text
646: 623 00012952 dd 8f00000db3 pushl $L302
647: 624 00012958 fe 08 effffffa59 callf $8,_writes
648: 625 0001295F # print_cmpf_data(); /* print the operands */
649: 626 0001295F fe 04 ef000005f2 callf $4,_print_cmpf_data
650: 627 00012966 # writes("\n");
651: 628 00012966 .data 1
652: 629 00000dda * L303:
653: 630 00000dda * 0A00 .ascii "\12\0"
654: 631 00000ddc * .text
655: 632 00012966 dd 8f00000dda pushl $L303
656: 633 0001296C fe 08 effffffa45 callf $8,_writes
657: 634 00012973 # writes("register "); /* print the information */
658: 635 00012973 .data 1
659: 636 00000ddc * L304:
660: 637 00000ddc * 72656769737465722000 .ascii "register \0"
661: 638 00000de6 * .text
662: 639 00012973 dd 8f00000ddc pushl $L304
663: 640 00012979 fe 08 effffffa38 callf $8,_writes
664: 641 00012980 # writed( index2 ); /* about the corrupted */
665: 642 00012980 dd effffffa32 pushl _index2
666: 643 00012986 fe 08 effffffa2b callf $8,_writed
667: 644 0001298D # writes(" = "); /* register */
668: 645 0001298D .data 1
669: 646 00000de6 * L305:
670: 647 00000de6 * 203D2000 .ascii " = \0"
671: 648 00000dea * .text
672: 649 0001298D dd 8f00000de6 pushl $L305
673: 650 00012993 fe 08 effffffa1e callf $8,_writes
674: 651 0001299A # write32h( store_regs[index2] );
675: 652 0001299A 0d effffffa18 50 movl _index2,r0
676: 653 000129A1 dd 40effffffa10 pushl _store_regs[r0]
677: 654 000129A8 fe 08 effffffa09 callf $8,_write32h
678: 655 000129AF # writes(", should be = ");
679: 656 000129AF .data 1
680: 657 00000dea * L306:
681: 658 00000dea * 2C202073686F756C642062652 .ascii ", should be = \0"
682: 03D2000
683: 659 00000dfa * .text
684: 660 000129AF dd 8f00000dea pushl $L306
685: 661 000129B5 fe 08 effffff9fc callf $8,_writes
686: 662 000129BC # write32h( load_regs[index2] );
687: 663 000129BC 0d effffff9f6 50 movl _index2,r0
688: 664 000129C3 dd 40effffff9ee pushl _load_regs[r0]
689: 665 000129CA fe 08 effffff9e7 callf $8,_write32h
690: 666 000129D1 # writes("\n");
691: 667 000129D1 .data 1
692: 668 00000dfa * L307:
693: 669 00000dfa * 0A00 .ascii "\12\0"
694: 670 00000dfc * .text
695: 671 000129D1 dd 8f00000dfa pushl $L307
696: 672 000129D7 fe 08 effffff9da callf $8,_writes
697: 673 000129DE # }
698: 674 000129DE # if ( halt_flg ) /* halt on error? */
699: 675 000129DE L298:
700: 676 000129DE 5d effffff9d4 tstl _halt_flg
701: 677 000129E4 31 09 jeql L308
702: 678 000129E6 # cmpf_er_halt( BAD_REG_HLT ); /* PC after the halt */
703: 679 000129E6 dd 02 pushl $2
704: 680 000129E8 fe 08 ef000005a5 callf $8,_cmpf_er_halt
705: 681 000129EF # if ( loop_on_err ) {
706: 682 000129EF L308:
707: 683 000129EF 5d effffff9c3 tstl _loop_on_err
708: 684 000129F5 31 0a jeql L309
709: 685 000129F7 # force_loop = TRUE; /* set the force loop flag */
710: 686 000129F7 0d 01 effffff9ba movl $1,_force_loop
711: 687 000129FE # asm("brw _cmpf_3_lp1"); /* and loop on the error */
712: 688 000129FE 13 fe8e brw _cmpf_3_lp1
713: 689 00012A01 # } /* end of loop on error */
714: 690 00012A01 # } /* end of register corruption error */
715: 691 00012A01 L309:
716: 692 00012A01 # } while( index++ < max_cmpf_1_index);/* end of data loop */
717: 693 00012A01 L297:
718: 694 00012A01 L292:
719: 695 00012A01 0d effffff9b1 50 movl _index,r0
720: 696 00012A08 6d effffff9aa incl _index
721: 697 00012A0E 1d 50 effffff9a3 cmpl r0,_max_cmpf_1_index
722: 698 00012A15 81 03 13 fe4f jlss L293
723: 699 00012A1A L291:
724: 700 00012A1A # } /* end of subtest 3 */
725: 701 00012A1A 40 ret#2
726: 702 00012A1B .set L286,0x0
727: 703 00012A1B L288:
728: 704 00012A1B 13 fe2b jbr L289
729: 705 00012A1E .data
730: 706 00000c8c * .text
731: 707 00012A1E .align 1
732: 708 00012A1E .globl _cmpf_4
733: 709 00012A1E _cmpf_4:
734: 710 00012A1E 0000 .word L310
735: 711 00012A20 #
736: 712 00012A20 #
737: 713 00012A20 #
738: 714 00012A20 # /************************************************************************
739: 715 00012A20 # *
740: 716 00012A20 # * SUBTEST 4 - Check for accumulator corruption
741: 717 00012A20 # *
742: 718 00012A20 # ************************************************************************/
743: 719 00012A20 # cmpf_4()
744: 720 00012A20 # {
745: 721 00012A20 13 0181 jbr L312
746: 722 00012A23 L313:
747: 723 00012A23 # force_loop = FALSE; /* clear force_loop flg */
748: 724 00012A23 4d effffff98f clrl _force_loop
749: 725 00012A29 # index = 0;
750: 726 00012A29 4d effffff989 clrl _index
751: 727 00012A2F # do
752: 728 00012A2F L316:
753: 729 00012A2F # {
754: 730 00012A2F # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
755: 731 00012A2F 5c 0c effffff982 50 mull3 $12,_index,r0
756: 732 00012A37 0d e000000000 effffff976 movl _cmpf_1_data(r0),_sgl_value_1
757: 733 00012A42 # sgl_value_2 = cmpf_1_data[index].two;
758: 734 00012A42 5c 0c effffff96f 50 mull3 $12,_index,r0
759: 735 00012A4A 0d e000000004 effffff963 movl _cmpf_1_data+4(r0),_sgl_value_2
760: 736 00012A55 # if( sgl_value_1 & 0x7f800000 )
761: 737 00012A55 3d 8f7f800000 effffff958 bitl $2139095040,_sgl_value_1
762: 738 00012A60 31 0d jeql L317
763: 739 00012A62 # sgl_expected = sgl_value_1; /* expected = loaded */
764: 740 00012A62 0d effffff950 effffff94b movl _sgl_value_1,_sgl_expected
765: 741 00012A6D # else
766: 742 00012A6D 11 06 jbr L318
767: 743 00012A6F L317:
768: 744 00012A6F # sgl_expected = 0; /* expect a '0' stored */
769: 745 00012A6F 4d effffff943 clrl _sgl_expected
770: 746 00012A75 L318:
771: 747 00012A75 # /*
772: 748 00012A75 # * If LOOP ON ERROR is set, this is the loop for this subtest.
773: 749 00012A75 # * The force loop flag is set after the first error.
774: 750 00012A75 # */
775: 751 00012A75 # asm("_cmpf_4_lp1:");
776: 752 00012A75 _cmpf_4_lp1:
777: 753 00012A75 # asm("ldf _sgl_value_1"); /* LOAD the accumulator */
778: 754 00012A75 06 effffff93d ldf _sgl_value_1
779: 755 00012A7B # asm("cmpf _sgl_value_2"); /* test the values */
780: 756 00012A7B 36 effffff937 cmpf _sgl_value_2
781: 757 00012A81 # asm("stf _sgl_st_acc"); /* store the accumulator */
782: 758 00012A81 26 effffff931 stf _sgl_st_acc
783: 759 00012A87 # if( force_loop ) /* loop? */
784: 760 00012A87 5d effffff92b tstl _force_loop
785: 761 00012A8D 31 02 jeql L319
786: 762 00012A8F # asm("brb _cmpf_4_lp1");; /* run the loop again */
787: 763 00012A8F 11 e4 brb _cmpf_4_lp1
788: 764 00012A91 L319:
789: 765 00012A91 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
790: 766 00012A91 1d effffff921 effffff91c cmpl _sgl_st_acc,_sgl_expected
791: 767 00012A9C 21 03 13 00e9 jeql L320
792: 768 00012AA1 # {
793: 769 00012AA1 # errcnt++; /* bump the error count */
794: 770 00012AA1 6d effffff911 incl _errcnt
795: 771 00012AA7 # if ( prt_error ) {
796: 772 00012AA7 5d effffff90b tstl _prt_error
797: 773 00012AAD 21 03 13 00b5 jeql L321
798: 774 00012AB2 # writes(" \n"); /* start a new print line */
799: 775 00012AB2 .data 1
800: 776 00000dfc * L322:
801: 777 00000dfc * 200A00 .ascii " \12\0"
802: 778 00000dff * .text
803: 779 00012AB2 dd 8f00000dfc pushl $L322
804: 780 00012AB8 fe 08 effffff8f9 callf $8,_writes
805: 781 00012ABF # writes("cycle: ");
806: 782 00012ABF .data 1
807: 783 00000dff * L323:
808: 784 00000dff * 6379636C653A2000 .ascii "cycle: \0"
809: 785 00000e07 * .text
810: 786 00012ABF dd 8f00000dff pushl $L323
811: 787 00012AC5 fe 08 effffff8ec callf $8,_writes
812: 788 00012ACC # writed( cycle );
813: 789 00012ACC dd effffff8e6 pushl _cycle
814: 790 00012AD2 fe 08 effffff8df callf $8,_writed
815: 791 00012AD9 # writes(" CMPF test ");
816: 792 00012AD9 .data 1
817: 793 00000e07 * L324:
818: 794 00000e07 * 2020434D50462074657374200 .ascii " CMPF test \0"
819: 0
820: 795 00000e14 * .text
821: 796 00012AD9 dd 8f00000e07 pushl $L324
822: 797 00012ADF fe 08 effffff8d2 callf $8,_writes
823: 798 00012AE6 # writed( test_no );
824: 799 00012AE6 dd effffff8cc pushl _test_no
825: 800 00012AEC fe 08 effffff8c5 callf $8,_writed
826: 801 00012AF3 # writes(", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\n");
827: 802 00012AF3 .data 1
828: 803 00000e14 * L325:
829: 804 00000e14 * 2C20737562746573742034202 .ascii ", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\12\0"
830: 8436163686520446174612920
831: 2D20544845204143432057415
832: 3204D4F4449464945440A00
833: 805 00000e45 * .text
834: 806 00012AF3 dd 8f00000e14 pushl $L325
835: 807 00012AF9 fe 08 effffff8b8 callf $8,_writes
836: 808 00012B00 # print_cmpf_data();
837: 809 00012B00 fe 04 ef00000451 callf $4,_print_cmpf_data
838: 810 00012B07 # writes(", data index = ");
839: 811 00012B07 .data 1
840: 812 00000e45 * L326:
841: 813 00000e45 * 2C20206461746120696E64657 .ascii ", data index = \0"
842: 8203D2000
843: 814 00000e56 * .text
844: 815 00012B07 dd 8f00000e45 pushl $L326
845: 816 00012B0D fe 08 effffff8a4 callf $8,_writes
846: 817 00012B14 # writed( index );
847: 818 00012B14 dd effffff89e pushl _index
848: 819 00012B1A fe 08 effffff897 callf $8,_writed
849: 820 00012B21 # writec('\n');
850: 821 00012B21 dd 0a pushl $10
851: 822 00012B23 fe 08 effffff88e callf $8,_writec
852: 823 00012B2A # writes(" final Acc = ");
853: 824 00012B2A .data 1
854: 825 00000e56 * L327:
855: 826 00000e56 * 202066696E616C20416363203 .ascii " final Acc = \0"
856: D2000
857: 827 00000e65 * .text
858: 828 00012B2A dd 8f00000e56 pushl $L327
859: 829 00012B30 fe 08 effffff881 callf $8,_writes
860: 830 00012B37 # write32h( sgl_st_acc );
861: 831 00012B37 dd effffff87b pushl _sgl_st_acc
862: 832 00012B3D fe 08 effffff874 callf $8,_write32h
863: 833 00012B44 # writes(", Acc expected = ");
864: 834 00012B44 .data 1
865: 835 00000e65 * L328:
866: 836 00000e65 * 2C20204163632065787065637 .ascii ", Acc expected = \0"
867: 46564203D2000
868: 837 00000e78 * .text
869: 838 00012B44 dd 8f00000e65 pushl $L328
870: 839 00012B4A fe 08 effffff867 callf $8,_writes
871: 840 00012B51 # write32h( sgl_expected );
872: 841 00012B51 dd effffff861 pushl _sgl_expected
873: 842 00012B57 fe 08 effffff85a callf $8,_write32h
874: 843 00012B5E # writec('\n');
875: 844 00012B5E dd 0a pushl $10
876: 845 00012B60 fe 08 effffff851 callf $8,_writec
877: 846 00012B67 # }
878: 847 00012B67 # if ( halt_flg ) /* halt on error? */
879: 848 00012B67 L321:
880: 849 00012B67 5d effffff84b tstl _halt_flg
881: 850 00012B6D 31 09 jeql L329
882: 851 00012B6F # cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */
883: 852 00012B6F dd 01 pushl $1
884: 853 00012B71 fe 08 ef0000041c callf $8,_cmpf_er_halt
885: 854 00012B78 # if ( loop_on_err ) {
886: 855 00012B78 L329:
887: 856 00012B78 5d effffff83a tstl _loop_on_err
888: 857 00012B7E 31 0a jeql L330
889: 858 00012B80 # force_loop = TRUE; /* set the force loop flag */
890: 859 00012B80 0d 01 effffff831 movl $1,_force_loop
891: 860 00012B87 # asm("brw _cmpf_4_lp1"); /* and loop on the error */
892: 861 00012B87 13 feeb brw _cmpf_4_lp1
893: 862 00012B8A # } /* end of loop on error */
894: 863 00012B8A # } /* end of compare error */
895: 864 00012B8A L330:
896: 865 00012B8A # } while( index++ < max_cmpf_1_index);/* end of data loop */
897: 866 00012B8A L320:
898: 867 00012B8A L315:
899: 868 00012B8A 0d effffff828 50 movl _index,r0
900: 869 00012B91 6d effffff821 incl _index
901: 870 00012B97 1d 50 effffff81a cmpl r0,_max_cmpf_1_index
902: 871 00012B9E 81 03 13 fe8c jlss L316
903: 872 00012BA3 L314:
904: 873 00012BA3 # } /* end of subtest 4 */
905: 874 00012BA3 40 ret#2
906: 875 00012BA4 .set L310,0x0
907: 876 00012BA4 L312:
908: 877 00012BA4 13 fe7c jbr L313
909: 878 00012BA7 .data
910: 879 00000c8c * .text
911: 880 00012BA7 00 .align 1
912: 881 00012BA8 .globl _cmpf_5
913: 882 00012BA8 _cmpf_5:
914: 883 00012BA8 0000 .word L331
915: 884 00012BAA #
916: 885 00012BAA #
917: 886 00012BAA #
918: 887 00012BAA # /****************************************************************************
919: 888 00012BAA # *
920: 889 00012BAA # * SUBTEST 5 - CMPF status test - piped entry
921: 890 00012BAA # *
922: 891 00012BAA # ****************************************************************************/
923: 892 00012BAA # cmpf_5()
924: 893 00012BAA # {
925: 894 00012BAA 13 0211 jbr L333
926: 895 00012BAD L334:
927: 896 00012BAD # force_loop = FALSE;
928: 897 00012BAD 4d effffff805 clrl _force_loop
929: 898 00012BB3 # subtest = 5;
930: 899 00012BB3 0d 05 effffff7fe movl $5,_subtest
931: 900 00012BBA # index = 0;
932: 901 00012BBA 4d effffff7f8 clrl _index
933: 902 00012BC0 # do
934: 903 00012BC0 L337:
935: 904 00012BC0 # {
936: 905 00012BC0 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
937: 906 00012BC0 5c 0c effffff7f1 50 mull3 $12,_index,r0
938: 907 00012BC8 0d e000000000 effffff7e5 movl _cmpf_1_data(r0),_sgl_value_1
939: 908 00012BD3 # sgl_value_2 = cmpf_1_data[index].two;
940: 909 00012BD3 5c 0c effffff7de 50 mull3 $12,_index,r0
941: 910 00012BDB 0d e000000004 effffff7d2 movl _cmpf_1_data+4(r0),_sgl_value_2
942: 911 00012BE6 # sgl_expected = cmpf_1_data[index].flag;/* get expected results */
943: 912 00012BE6 5c 0c effffff7cb 50 mull3 $12,_index,r0
944: 913 00012BEE 0d e000000008 effffff7bf movl _cmpf_1_data+8(r0),_sgl_expected
945: 914 00012BF9 # status_index = 0; /* clear the status index */
946: 915 00012BF9 4d effffff7b9 clrl _status_index
947: 916 00012BFF # do
948: 917 00012BFF L340:
949: 918 00012BFF # {
950: 919 00012BFF # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
951: 920 00012BFF 0d effffff7b3 50 movl _status_index,r0
952: 921 00012C06 0d 40effffff7ab movl _status_array[r0],_sgl_dummy1
953: effffff7a6
954: 922 00012C12 # /*
955: 923 00012C12 # * If LOOP ON ERROR is set, this is the loop for this subtest.
956: 924 00012C12 # * The force loop flag is set after the first error.
957: 925 00012C12 # */
958: 926 00012C12 # asm("_cmpf_5_lp1:");
959: 927 00012C12 _cmpf_5_lp1:
960: 928 00012C12 # asm("movl $0,r0"); /* clear r0 */
961: 929 00012C12 0d 00 50 movl $0,r0
962: 930 00012C15 # asm("ldf r0"); /* load the accumulator */
963: 931 00012C15 06 50 ldf r0
964: 932 00012C17 # asm("addf _sgl_value_1"); /* add the 1st operand */
965: 933 00012C17 c6 effffff79b addf _sgl_value_1
966: 934 00012C1D # asm("tstl _sgl_dummy1"); /* generate initial status */
967: 935 00012C1D 5d effffff795 tstl _sgl_dummy1
968: 936 00012C23 # asm("movpsl _init_psl"); /* save the initial status */
969: 937 00012C23 cd effffff78f movpsl _init_psl
970: 938 00012C29 # asm("cmpf _sgl_value_2"); /* compare the operands */
971: 939 00012C29 36 effffff789 cmpf _sgl_value_2
972: 940 00012C2F # asm("movpsl _psl_val"); /* save the final status */
973: 941 00012C2F cd effffff783 movpsl _psl_val
974: 942 00012C35 # asm("stf _sgl_st_acc"); /* save the final acc */
975: 943 00012C35 26 effffff77d stf _sgl_st_acc
976: 944 00012C3B # if( force_loop ) /* loop? */
977: 945 00012C3B 5d effffff777 tstl _force_loop
978: 946 00012C41 31 02 jeql L341
979: 947 00012C43 # asm("brb _cmpf_5_lp1");; /* run the loop again */
980: 948 00012C43 11 cd brb _cmpf_5_lp1
981: 949 00012C45 L341:
982: 950 00012C45 # exp_psl = init_psl; /* get the initial PSL */
983: 951 00012C45 0d effffff76d effffff768 movl _init_psl,_exp_psl
984: 952 00012C50 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
985: 953 00012C50 ac 88f3 effffff760 andl2 $-13,_exp_psl
986: 954 00012C58 # if( sgl_expected == ZERO )
987: 955 00012C58 1d effffff75a 04 cmpl _sgl_expected,$4
988: 956 00012C5F 21 07 jneq L342
989: 957 00012C61 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
990: 958 00012C61 8c 04 effffff750 orl2 $4,_exp_psl
991: 959 00012C68 # if( sgl_expected == NEGATIVE )
992: 960 00012C68 L342:
993: 961 00012C68 1d effffff74a 08 cmpl _sgl_expected,$8
994: 962 00012C6F 21 07 jneq L343
995: 963 00012C71 # exp_psl |= PSL_N; /* expect the NEG bit set */
996: 964 00012C71 8c 08 effffff740 orl2 $8,_exp_psl
997: 965 00012C78 # if( psl_val != exp_psl ) { /* COMPARE the values */
998: 966 00012C78 L343:
999: 967 00012C78 1d effffff73a effffff735 cmpl _psl_val,_exp_psl
1000: 968 00012C83 21 03 13 0107 jeql L344
1001: 969 00012C88 # errcnt++; /* bump the error count */
1002: 970 00012C88 6d effffff72a incl _errcnt
1003: 971 00012C8E # if ( prt_error ) {
1004: 972 00012C8E 5d effffff724 tstl _prt_error
1005: 973 00012C94 21 03 13 00d3 jeql L345
1006: 974 00012C99 # writes(" \n"); /* start a new print line */
1007: 975 00012C99 .data 1
1008: 976 00000e78 * L346:
1009: 977 00000e78 * 200A00 .ascii " \12\0"
1010: 978 00000e7b * .text
1011: 979 00012C99 dd 8f00000e78 pushl $L346
1012: 980 00012C9F fe 08 effffff712 callf $8,_writes
1013: 981 00012CA6 # writes("cycle: ");
1014: 982 00012CA6 .data 1
1015: 983 00000e7b * L347:
1016: 984 00000e7b * 6379636C653A2000 .ascii "cycle: \0"
1017: 985 00000e83 * .text
1018: 986 00012CA6 dd 8f00000e7b pushl $L347
1019: 987 00012CAC fe 08 effffff705 callf $8,_writes
1020: 988 00012CB3 # writed( cycle );
1021: 989 00012CB3 dd effffff6ff pushl _cycle
1022: 990 00012CB9 fe 08 effffff6f8 callf $8,_writed
1023: 991 00012CC0 # writes(" CMPF test ");
1024: 992 00012CC0 .data 1
1025: 993 00000e83 * L348:
1026: 994 00000e83 * 2020434D50462074657374200 .ascii " CMPF test \0"
1027: 0
1028: 995 00000e90 * .text
1029: 996 00012CC0 dd 8f00000e83 pushl $L348
1030: 997 00012CC6 fe 08 effffff6eb callf $8,_writes
1031: 998 00012CCD # writed( test_no );
1032: 999 00012CCD dd effffff6e5 pushl _test_no
1033: 1000 00012CD3 fe 08 effffff6de callf $8,_writed
1034: 1001 00012CDA # writes(", subtest 5 (Piped Entry) - BAD FINAL PSL\n");
1035: 1002 00012CDA .data 1
1036: 1003 00000e90 * L349:
1037: 1004 00000e90 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL PSL\12\0"
1038: 8506970656420456E74727929
1039: 202D204241442046494E414C2
1040: 050534C0A00
1041: 1005 00000ebb * .text
1042: 1006 00012CDA dd 8f00000e90 pushl $L349
1043: 1007 00012CE0 fe 08 effffff6d1 callf $8,_writes
1044: 1008 00012CE7 # print_cmpf_data();
1045: 1009 00012CE7 fe 04 ef0000026a callf $4,_print_cmpf_data
1046: 1010 00012CEE # writes(", data index = ");
1047: 1011 00012CEE .data 1
1048: 1012 00000ebb * L350:
1049: 1013 00000ebb * 2C20206461746120696E64657 .ascii ", data index = \0"
1050: 8203D2000
1051: 1014 00000ecc * .text
1052: 1015 00012CEE dd 8f00000ebb pushl $L350
1053: 1016 00012CF4 fe 08 effffff6bd callf $8,_writes
1054: 1017 00012CFB # writed( index );
1055: 1018 00012CFB dd effffff6b7 pushl _index
1056: 1019 00012D01 fe 08 effffff6b0 callf $8,_writed
1057: 1020 00012D08 # writec('\n');
1058: 1021 00012D08 dd 0a pushl $10
1059: 1022 00012D0A fe 08 effffff6a7 callf $8,_writec
1060: 1023 00012D11 # writes("initial PSL = ");
1061: 1024 00012D11 .data 1
1062: 1025 00000ecc * L351:
1063: 1026 00000ecc * 696E697469616C2050534C203 .ascii "initial PSL = \0"
1064: D2000
1065: 1027 00000edb * .text
1066: 1028 00012D11 dd 8f00000ecc pushl $L351
1067: 1029 00012D17 fe 08 effffff69a callf $8,_writes
1068: 1030 00012D1E # write32h( init_psl );
1069: 1031 00012D1E dd effffff694 pushl _init_psl
1070: 1032 00012D24 fe 08 effffff68d callf $8,_write32h
1071: 1033 00012D2B # writes(", final PSL = ");
1072: 1034 00012D2B .data 1
1073: 1035 00000edb * L352:
1074: 1036 00000edb * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
1075: 03D2000
1076: 1037 00000eeb * .text
1077: 1038 00012D2B dd 8f00000edb pushl $L352
1078: 1039 00012D31 fe 08 effffff680 callf $8,_writes
1079: 1040 00012D38 # write32h( psl_val );
1080: 1041 00012D38 dd effffff67a pushl _psl_val
1081: 1042 00012D3E fe 08 effffff673 callf $8,_write32h
1082: 1043 00012D45 # writes(", expected PSL = ");
1083: 1044 00012D45 .data 1
1084: 1045 00000eeb * L353:
1085: 1046 00000eeb * 2C20206578706563746564205 .ascii ", expected PSL = \0"
1086: 0534C203D2000
1087: 1047 00000efe * .text
1088: 1048 00012D45 dd 8f00000eeb pushl $L353
1089: 1049 00012D4B fe 08 effffff666 callf $8,_writes
1090: 1050 00012D52 # write32h( exp_psl );
1091: 1051 00012D52 dd effffff660 pushl _exp_psl
1092: 1052 00012D58 fe 08 effffff659 callf $8,_write32h
1093: 1053 00012D5F # writes("\n");
1094: 1054 00012D5F .data 1
1095: 1055 00000efe * L354:
1096: 1056 00000efe * 0A00 .ascii "\12\0"
1097: 1057 00000f00 * .text
1098: 1058 00012D5F dd 8f00000efe pushl $L354
1099: 1059 00012D65 fe 08 effffff64c callf $8,_writes
1100: 1060 00012D6C # }
1101: 1061 00012D6C # if ( halt_flg )
1102: 1062 00012D6C L345:
1103: 1063 00012D6C 5d effffff646 tstl _halt_flg
1104: 1064 00012D72 31 09 jeql L355
1105: 1065 00012D74 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
1106: 1066 00012D74 dd 03 pushl $3
1107: 1067 00012D76 fe 08 ef00000217 callf $8,_cmpf_er_halt
1108: 1068 00012D7D # if ( loop_on_err ) {
1109: 1069 00012D7D L355:
1110: 1070 00012D7D 5d effffff635 tstl _loop_on_err
1111: 1071 00012D83 31 0a jeql L356
1112: 1072 00012D85 # force_loop = TRUE; /* set the force loop flag */
1113: 1073 00012D85 0d 01 effffff62c movl $1,_force_loop
1114: 1074 00012D8C # asm("brw _cmpf_5_lp1"); /* and loop on the error */
1115: 1075 00012D8C 13 fe83 brw _cmpf_5_lp1
1116: 1076 00012D8F # } /* end of loop on error */
1117: 1077 00012D8F # } /* end of compare error */
1118: 1078 00012D8F L356:
1119: 1079 00012D8F # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
1120: 1080 00012D8F L344:
1121: 1081 00012D8F L339:
1122: 1082 00012D8F 6d effffff623 incl _status_index
1123: 1083 00012D95 0d effffff61d 50 movl _status_index,r0
1124: 1084 00012D9C 1d 50 03 cmpl r0,$3
1125: 1085 00012D9F 81 03 13 fe5b jlss L340
1126: 1086 00012DA4 L338:
1127: 1087 00012DA4 # } while( index++ < max_cmpf_1_index);/* end of data loop */
1128: 1088 00012DA4 L336:
1129: 1089 00012DA4 0d effffff60e 50 movl _index,r0
1130: 1090 00012DAB 6d effffff607 incl _index
1131: 1091 00012DB1 1d 50 effffff600 cmpl r0,_max_cmpf_1_index
1132: 1092 00012DB8 81 03 13 fe03 jlss L337
1133: 1093 00012DBD L335:
1134: 1094 00012DBD # } /* end of subtest 5 */
1135: 1095 00012DBD 40 ret#2
1136: 1096 00012DBE .set L331,0x0
1137: 1097 00012DBE L333:
1138: 1098 00012DBE 13 fdec jbr L334
1139: 1099 00012DC1 .data
1140: 1100 00000c8c * .text
1141: 1101 00012DC1 00 .align 1
1142: 1102 00012DC2 .globl _cmpf_6
1143: 1103 00012DC2 _cmpf_6:
1144: 1104 00012DC2 0000 .word L357
1145: 1105 00012DC4 #
1146: 1106 00012DC4 #
1147: 1107 00012DC4 #
1148: 1108 00012DC4 # /****************************************************************************
1149: 1109 00012DC4 # *
1150: 1110 00012DC4 # * SUBTEST 6 - CMPF status test -piped exit
1151: 1111 00012DC4 # *
1152: 1112 00012DC4 # ****************************************************************************/
1153: 1113 00012DC4 # cmpf_6()
1154: 1114 00012DC4 # {
1155: 1115 00012DC4 13 018d jbr L359
1156: 1116 00012DC7 L360:
1157: 1117 00012DC7 # force_loop = FALSE;
1158: 1118 00012DC7 4d effffff5eb clrl _force_loop
1159: 1119 00012DCD # subtest = 2;
1160: 1120 00012DCD 0d 02 effffff5e4 movl $2,_subtest
1161: 1121 00012DD4 # index = 0;
1162: 1122 00012DD4 4d effffff5de clrl _index
1163: 1123 00012DDA # do
1164: 1124 00012DDA L363:
1165: 1125 00012DDA # {
1166: 1126 00012DDA # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
1167: 1127 00012DDA 5c 0c effffff5d7 50 mull3 $12,_index,r0
1168: 1128 00012DE2 0d e000000000 effffff5cb movl _cmpf_1_data(r0),_sgl_value_1
1169: 1129 00012DED # sgl_value_2 = cmpf_1_data[index].two;
1170: 1130 00012DED 5c 0c effffff5c4 50 mull3 $12,_index,r0
1171: 1131 00012DF5 0d e000000004 effffff5b8 movl _cmpf_1_data+4(r0),_sgl_value_2
1172: 1132 00012E00 # if( sgl_value_1 & 0x7f800000 )
1173: 1133 00012E00 3d 8f7f800000 effffff5ad bitl $2139095040,_sgl_value_1
1174: 1134 00012E0B 31 0d jeql L364
1175: 1135 00012E0D # sgl_expected = sgl_value_1; /* expected = loaded */
1176: 1136 00012E0D 0d effffff5a5 effffff5a0 movl _sgl_value_1,_sgl_expected
1177: 1137 00012E18 # else
1178: 1138 00012E18 11 06 jbr L365
1179: 1139 00012E1A L364:
1180: 1140 00012E1A # sgl_expected = 0; /* expect a '0' stored */
1181: 1141 00012E1A 4d effffff598 clrl _sgl_expected
1182: 1142 00012E20 L365:
1183: 1143 00012E20 # /*
1184: 1144 00012E20 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1185: 1145 00012E20 # * The force loop flag is set after the first error.
1186: 1146 00012E20 # */
1187: 1147 00012E20 # asm("_cmpf_6_lp1:");
1188: 1148 00012E20 _cmpf_6_lp1:
1189: 1149 00012E20 # asm("movl $0,r0"); /* clear r0 */
1190: 1150 00012E20 0d 00 50 movl $0,r0
1191: 1151 00012E23 # asm("ldf _sgl_value_1"); /* load the 1st operand */
1192: 1152 00012E23 06 effffff58f ldf _sgl_value_1
1193: 1153 00012E29 # asm("cmpf _sgl_value_2"); /* compare the value */
1194: 1154 00012E29 36 effffff589 cmpf _sgl_value_2
1195: 1155 00012E2F # asm("addf r0"); /* add a zero to the acc */
1196: 1156 00012E2F c6 50 addf r0
1197: 1157 00012E31 # asm("stf _sgl_st_acc"); /* save the accumulator */
1198: 1158 00012E31 26 effffff581 stf _sgl_st_acc
1199: 1159 00012E37 # if( force_loop ) /* loop? */
1200: 1160 00012E37 5d effffff57b tstl _force_loop
1201: 1161 00012E3D 31 02 jeql L366
1202: 1162 00012E3F # asm("brb _cmpf_6_lp1");; /* run the loop again */
1203: 1163 00012E3F 11 df brb _cmpf_6_lp1
1204: 1164 00012E41 L366:
1205: 1165 00012E41 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1206: 1166 00012E41 1d effffff571 effffff56c cmpl _sgl_st_acc,_sgl_expected
1207: 1167 00012E4C 21 03 13 00e9 jeql L367
1208: 1168 00012E51 # errcnt++; /* bump the error count */
1209: 1169 00012E51 6d effffff561 incl _errcnt
1210: 1170 00012E57 # if ( prt_error ) {
1211: 1171 00012E57 5d effffff55b tstl _prt_error
1212: 1172 00012E5D 21 03 13 00b5 jeql L368
1213: 1173 00012E62 # writes(" \n"); /* start a new print line */
1214: 1174 00012E62 .data 1
1215: 1175 00000f00 * L369:
1216: 1176 00000f00 * 200A00 .ascii " \12\0"
1217: 1177 00000f03 * .text
1218: 1178 00012E62 dd 8f00000f00 pushl $L369
1219: 1179 00012E68 fe 08 effffff549 callf $8,_writes
1220: 1180 00012E6F # writes("cycle: ");
1221: 1181 00012E6F .data 1
1222: 1182 00000f03 * L370:
1223: 1183 00000f03 * 6379636C653A2000 .ascii "cycle: \0"
1224: 1184 00000f0b * .text
1225: 1185 00012E6F dd 8f00000f03 pushl $L370
1226: 1186 00012E75 fe 08 effffff53c callf $8,_writes
1227: 1187 00012E7C # writed( cycle );
1228: 1188 00012E7C dd effffff536 pushl _cycle
1229: 1189 00012E82 fe 08 effffff52f callf $8,_writed
1230: 1190 00012E89 # writes(" CMPF test ");
1231: 1191 00012E89 .data 1
1232: 1192 00000f0b * L371:
1233: 1193 00000f0b * 2020434D50462074657374200 .ascii " CMPF test \0"
1234: 0
1235: 1194 00000f18 * .text
1236: 1195 00012E89 dd 8f00000f0b pushl $L371
1237: 1196 00012E8F fe 08 effffff522 callf $8,_writes
1238: 1197 00012E96 # writed( test_no );
1239: 1198 00012E96 dd effffff51c pushl _test_no
1240: 1199 00012E9C fe 08 effffff515 callf $8,_writed
1241: 1200 00012EA3 # writes(", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\n");
1242: 1201 00012EA3 .data 1
1243: 1202 00000f18 * L372:
1244: 1203 00000f18 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\12\0"
1245: 8506970656420457869742920
1246: 2D20544845204143432057415
1247: 3204D4F4449464945440A00
1248: 1204 00000f49 * .text
1249: 1205 00012EA3 dd 8f00000f18 pushl $L372
1250: 1206 00012EA9 fe 08 effffff508 callf $8,_writes
1251: 1207 00012EB0 # print_cmpf_data();
1252: 1208 00012EB0 fe 04 ef000000a1 callf $4,_print_cmpf_data
1253: 1209 00012EB7 # writes(", data index = ");
1254: 1210 00012EB7 .data 1
1255: 1211 00000f49 * L373:
1256: 1212 00000f49 * 2C20206461746120696E64657 .ascii ", data index = \0"
1257: 8203D2000
1258: 1213 00000f5a * .text
1259: 1214 00012EB7 dd 8f00000f49 pushl $L373
1260: 1215 00012EBD fe 08 effffff4f4 callf $8,_writes
1261: 1216 00012EC4 # writed( index );
1262: 1217 00012EC4 dd effffff4ee pushl _index
1263: 1218 00012ECA fe 08 effffff4e7 callf $8,_writed
1264: 1219 00012ED1 # writec('\n');
1265: 1220 00012ED1 dd 0a pushl $10
1266: 1221 00012ED3 fe 08 effffff4de callf $8,_writec
1267: 1222 00012EDA # writes(" final Acc = ");
1268: 1223 00012EDA .data 1
1269: 1224 00000f5a * L374:
1270: 1225 00000f5a * 202066696E616C20416363203 .ascii " final Acc = \0"
1271: D2000
1272: 1226 00000f69 * .text
1273: 1227 00012EDA dd 8f00000f5a pushl $L374
1274: 1228 00012EE0 fe 08 effffff4d1 callf $8,_writes
1275: 1229 00012EE7 # write32h( sgl_st_acc );
1276: 1230 00012EE7 dd effffff4cb pushl _sgl_st_acc
1277: 1231 00012EED fe 08 effffff4c4 callf $8,_write32h
1278: 1232 00012EF4 # writes(", Acc expected = ");
1279: 1233 00012EF4 .data 1
1280: 1234 00000f69 * L375:
1281: 1235 00000f69 * 2C20204163632065787065637 .ascii ", Acc expected = \0"
1282: 46564203D2000
1283: 1236 00000f7c * .text
1284: 1237 00012EF4 dd 8f00000f69 pushl $L375
1285: 1238 00012EFA fe 08 effffff4b7 callf $8,_writes
1286: 1239 00012F01 # write32h( sgl_expected );
1287: 1240 00012F01 dd effffff4b1 pushl _sgl_expected
1288: 1241 00012F07 fe 08 effffff4aa callf $8,_write32h
1289: 1242 00012F0E # writec('\n');
1290: 1243 00012F0E dd 0a pushl $10
1291: 1244 00012F10 fe 08 effffff4a1 callf $8,_writec
1292: 1245 00012F17 # }
1293: 1246 00012F17 # if ( halt_flg )
1294: 1247 00012F17 L368:
1295: 1248 00012F17 5d effffff49b tstl _halt_flg
1296: 1249 00012F1D 31 09 jeql L376
1297: 1250 00012F1F # cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1298: 1251 00012F1F dd 01 pushl $1
1299: 1252 00012F21 fe 08 ef0000006c callf $8,_cmpf_er_halt
1300: 1253 00012F28 # if ( loop_on_err ) {
1301: 1254 00012F28 L376:
1302: 1255 00012F28 5d effffff48a tstl _loop_on_err
1303: 1256 00012F2E 31 0a jeql L377
1304: 1257 00012F30 # force_loop = TRUE; /* set the force loop flag */
1305: 1258 00012F30 0d 01 effffff481 movl $1,_force_loop
1306: 1259 00012F37 # asm("brw _cmpf_6_lp1"); /* and loop on the error */
1307: 1260 00012F37 13 fee6 brw _cmpf_6_lp1
1308: 1261 00012F3A # } /* end of loop on error */
1309: 1262 00012F3A # } /* end of compare error */
1310: 1263 00012F3A L377:
1311: 1264 00012F3A # } while( index++ < max_cmpf_1_index); /* end of data loop */
1312: 1265 00012F3A L367:
1313: 1266 00012F3A L362:
1314: 1267 00012F3A 0d effffff478 50 movl _index,r0
1315: 1268 00012F41 6d effffff471 incl _index
1316: 1269 00012F47 1d 50 effffff46a cmpl r0,_max_cmpf_1_index
1317: 1270 00012F4E 81 03 13 fe87 jlss L363
1318: 1271 00012F53 L361:
1319: 1272 00012F53 # } /* end of subtest 6 */
1320: 1273 00012F53 40 ret#2
1321: 1274 00012F54 .set L357,0x0
1322: 1275 00012F54 L359:
1323: 1276 00012F54 13 fe70 jbr L360
1324: 1277 00012F57 .data
1325: 1278 00000c8c * .text
1326: 1279 00012F57 00 .align 1
1327: 1280 00012F58 .globl _print_cmpf_data
1328: 1281 00012F58 _print_cmpf_data:
1329: 1282 00012F58 0000 .word L378
1330: 1283 00012F5A #
1331: 1284 00012F5A #
1332: 1285 00012F5A #
1333: 1286 00012F5A # /**************************************************************************
1334: 1287 00012F5A # *
1335: 1288 00012F5A # * PRINT THE DATA AND STORE RESULTS
1336: 1289 00012F5A # *
1337: 1290 00012F5A # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1338: 1291 00012F5A # * operand = xxxxxxxx, expected = xxxxxxxx
1339: 1292 00012F5A # **************************************************************************/
1340: 1293 00012F5A # print_cmpf_data()
1341: 1294 00012F5A # {
1342: 1295 00012F5A 11 35 jbr L380
1343: 1296 00012F5C L381:
1344: 1297 00012F5C # writes("initial Acc = ");
1345: 1298 00012F5C .data 1
1346: 1299 00000f7c * L382:
1347: 1300 00000f7c * 696E697469616C20416363203 .ascii "initial Acc = \0"
1348: D2000
1349: 1301 00000f8b * .text
1350: 1302 00012F5C dd 8f00000f7c pushl $L382
1351: 1303 00012F62 fe 08 effffff44f callf $8,_writes
1352: 1304 00012F69 # write32h( sgl_value_1 );
1353: 1305 00012F69 dd effffff449 pushl _sgl_value_1
1354: 1306 00012F6F fe 08 effffff442 callf $8,_write32h
1355: 1307 00012F76 # writes(", operand = ");
1356: 1308 00012F76 .data 1
1357: 1309 00000f8b * L383:
1358: 1310 00000f8b * 2C2020206F706572616E64203 .ascii ", operand = \0"
1359: D2000
1360: 1311 00000f9a * .text
1361: 1312 00012F76 dd 8f00000f8b pushl $L383
1362: 1313 00012F7C fe 08 effffff435 callf $8,_writes
1363: 1314 00012F83 # write32h( sgl_value_2 );
1364: 1315 00012F83 dd effffff42f pushl _sgl_value_2
1365: 1316 00012F89 fe 08 effffff428 callf $8,_write32h
1366: 1317 00012F90 # }
1367: 1318 00012F90 40 ret#2
1368: 1319 00012F91 .set L378,0x0
1369: 1320 00012F91 L380:
1370: 1321 00012F91 11 c9 jbr L381
1371: 1322 00012F93 .data
1372: 1323 00000c8c * .text
1373: 1324 00012F93 00 .align 1
1374: 1325 00012F94 .globl _cmpf_er_halt
1375: 1326 00012F94 _cmpf_er_halt:
1376: 1327 00012F94 0000 .word L384
1377: 1328 00012F96 #
1378: 1329 00012F96 #
1379: 1330 00012F96 #
1380: 1331 00012F96 # /**************************************************************************
1381: 1332 00012F96 # *
1382: 1333 00012F96 # * HALT ON ERROR ROUTINE
1383: 1334 00012F96 # *
1384: 1335 00012F96 # **************************************************************************/
1385: 1336 00012F96 # cmpf_er_halt( halt_code )
1386: 1337 00012F96 # int halt_code;
1387: 1338 00012F96 # {
1388: 1339 00012F96 13 00a8 jbr L386
1389: 1340 00012F99 L387:
1390: 1341 00012F99 # sgl_dummy1 = halt_code; /* get the error type */
1391: 1342 00012F99 0d ad04 effffff417 movl 4(fp),_sgl_dummy1
1392: 1343 00012FA1 # asm("movl _test_no,r0"); /* r0 = test number */
1393: 1344 00012FA1 0d effffff411 50 movl _test_no,r0
1394: 1345 00012FA8 # asm("movl _subtest,r1"); /* r1 = subtest number */
1395: 1346 00012FA8 0d effffff40a 51 movl _subtest,r1
1396: 1347 00012FAF # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1397: 1348 00012FAF 0d effffff403 52 movl _sgl_dummy1,r2
1398: 1349 00012FB6 # asm("movl _cycle,r3"); /* r3 = cycle count */
1399: 1350 00012FB6 0d effffff3fc 53 movl _cycle,r3
1400: 1351 00012FBD # asm("movl _sgl_value_1,r4"); /* r4 = initial acc */
1401: 1352 00012FBD 0d effffff3f5 54 movl _sgl_value_1,r4
1402: 1353 00012FC4 # asm("movl _sgl_value_2,r5"); /* r5 = data compared */
1403: 1354 00012FC4 0d effffff3ee 55 movl _sgl_value_2,r5
1404: 1355 00012FCB # asm("movl _psl_val,r6"); /* r6 = final PSL */
1405: 1356 00012FCB 0d effffff3e7 56 movl _psl_val,r6
1406: 1357 00012FD2 # if( halt_code == BAD_ACC_HLT ) {
1407: 1358 00012FD2 1d ad04 01 cmpl 4(fp),$1
1408: 1359 00012FD6 21 10 jneq L388
1409: 1360 00012FD8 # asm("movl _sgl_st_acc,r7"); /* r7 = actual value */
1410: 1361 00012FD8 0d effffff3da 57 movl _sgl_st_acc,r7
1411: 1362 00012FDF # asm("movl _sgl_expected,r8"); /* r8 = expected value */
1412: 1363 00012FDF 0d effffff3d3 58 movl _sgl_expected,r8
1413: 1364 00012FE6 # } else
1414: 1365 00012FE6 11 57 jbr L389
1415: 1366 00012FE8 L388:
1416: 1367 00012FE8 # if( halt_code == BAD_REG_HLT ) {
1417: 1368 00012FE8 1d ad04 02 cmpl 4(fp),$2
1418: 1369 00012FEC 21 3d jneq L390
1419: 1370 00012FEE # sgl_dummy1 = load_regs[index2];
1420: 1371 00012FEE 0d effffff3c4 50 movl _index2,r0
1421: 1372 00012FF5 0d 40effffff3bc movl _load_regs[r0],_sgl_dummy1
1422: effffff3b7
1423: 1373 00013001 # sgl_dummy2 = store_regs[index2];
1424: 1374 00013001 0d effffff3b1 50 movl _index2,r0
1425: 1375 00013008 0d 40effffff3a9 movl _store_regs[r0],_sgl_dummy2
1426: effffff3a4
1427: 1376 00013014 # asm("movl _index2,r7"); /* r7 = bad register # */
1428: 1377 00013014 0d effffff39e 57 movl _index2,r7
1429: 1378 0001301B # asm("movl _sgl_dummy2,r8"); /* r8 = actual value */
1430: 1379 0001301B 0d effffff397 58 movl _sgl_dummy2,r8
1431: 1380 00013022 # asm("movl _sgl_dummy1,r9"); /* r9 = expected value */
1432: 1381 00013022 0d effffff390 59 movl _sgl_dummy1,r9
1433: 1382 00013029 # } else
1434: 1383 00013029 11 14 jbr L391
1435: 1384 0001302B L390:
1436: 1385 0001302B # if( halt_code == BAD_PSL_HLT ) {
1437: 1386 0001302B 1d ad04 03 cmpl 4(fp),$3
1438: 1387 0001302F 21 0e jneq L392
1439: 1388 00013031 # asm("movl _exp_psl,r7"); /* r7 = expected PSL */
1440: 1389 00013031 0d effffff381 57 movl _exp_psl,r7
1441: 1390 00013038 # asm("movl _index,r7"); /* r8 = data index */
1442: 1391 00013038 0d effffff37a 57 movl _index,r7
1443: 1392 0001303F # };
1444: 1393 0001303F L392:
1445: 1394 0001303F L391:
1446: 1395 0001303F L389:
1447: 1396 0001303F # asm("halt"); /* HALT ... */
1448: 1397 0001303F 00 halt
1449: 1398 00013040 # }
1450: 1399 00013040 40 ret#2
1451: 1400 00013041 .set L384,0x0
1452: 1401 00013041 L386:
1453: 1402 00013041 13 ff55 jbr L387
1454: 1403 00000c8c * .data
1455: 1403 00000c8c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.