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