![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpd2.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 cmpd2.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 00001398 * .text
4 00000000 .align 1
5 00000000 .globl _cmpd2
6 00000000 _cmpd2:
7 0001BDF0 0000 .word L215
8 0001BDF2 # #include "fpp_defs.h"
9 0001BDF2 #
10 0001BDF2 #
11 0001BDF2 #
12 0001BDF2 # /***************************************************************************
13 0001BDF2 # *
14 0001BDF2 # * CMPD2 -COMPARE 2 DBL OPERANDS TO EACH OTHER -IGNORE THE ACCUMULATOR
15 0001BDF2 # *
16 0001BDF2 # *****************************************************************************/
17 0001BDF2 # cmpd2()
18 0001BDF2 # {
19 0001BDF2 11 4f jbr L217
20 0001BDF4 L218:
21 0001BDF4 # asm(".globl _cmpd2_t");
22 0001BDF4 .globl _cmpd2_t
23 0001BDF4 # asm("_cmpd2_t:"); /* entry address */
24 0001BDF4 _cmpd2_t:
25 0001BDF4 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26 0001BDF4 1d effffffff6 01 cmpl _cycle,$1
27 0001BDFB 21 15 jneq L219
28 0001BDFD 5d efffffffed tstl _prt_hdrs
29 0001BE03 31 0d jeql L219
30 0001BE05 # writes(" CMPD2");
31 0001BE05 .data 1
32 00001398 * L221:
33 00001398 * 20434D50443200 .ascii " CMPD2\0"
34 0000139f * .text
35 0001BE05 dd 8f00001398 pushl $L221
36 0001BE0B fe 08 efffffffde callf $8,_writes
37 0001BE12 # cmpd2_1(); /* register / register data */
38 0001BE12 L219:
39 0001BE12 fe 04 ef0000002d callf $4,_cmpd2_1
40 0001BE19 # cmpd2_2(); /* cache / cache data */
41 0001BE19 fe 04 ef00000342 callf $4,_cmpd2_2
42 0001BE20 # cmpd2_3(); /* cache / register data */
43 0001BE20 fe 04 ef00000645 callf $4,_cmpd2_3
44 0001BE27 # cmpd2_4(); /* register / cache data */
45 0001BE27 fe 04 ef00000952 callf $4,_cmpd2_4
46 0001BE2E # cmpd2_5(); /* acc. corruption test */
47 0001BE2E fe 04 ef00000c61 callf $4,_cmpd2_5
48 0001BE35 # cmpd2_6(); /* register corruption test */
49 0001BE35 fe 04 ef00000ef8 callf $4,_cmpd2_6
50 0001BE3C # asm("jmp *return"); /* return to the test monitor */
51 0001BE3C 71 ffffffffae jmp *return
52 0001BE42 # }
53 0001BE42 40 ret#2
54 0001BE43 .set L215,0x0
55 0001BE43 L217:
56 0001BE43 11 af jbr L218
57 0001BE45 .data
58 00001398 * .text
59 0001BE45 00 .align 1
60 0001BE46 .globl _cmpd2_1
61 0001BE46 _cmpd2_1:
62 0001BE46 0000 .word L228
63 0001BE48 #
64 0001BE48 #
65 0001BE48 #
66 0001BE48 # /****************************************************************************
67 0001BE48 # *
68 0001BE48 # * SUBTEST 1 - CMPD2 test -register / register data
69 0001BE48 # *
70 0001BE48 # ****************************************************************************/
71 0001BE48 # cmpd2_1()
72 0001BE48 # {
73 0001BE48 13 0314 jbr L230
74 0001BE4B L231:
75 0001BE4B # force_loop = FALSE;
76 0001BE4B 4d efffffff9f clrl _force_loop
77 0001BE51 # subtest = 1;
78 0001BE51 0d 01 efffffff98 movl $1,_subtest
79 0001BE58 # index = 0;
80 0001BE58 4d efffffff92 clrl _index
81 0001BE5E # do
82 0001BE5E L234:
83 0001BE5E # {
84 0001BE5E # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
85 0001BE5E 5c 14 efffffff8b 50 mull3 $20,_index,r0
86 0001BE66 0c 8f00000000 50 addl2 $_cmpd_1_data,r0
87 0001BE6D 0d a004 efffffff7f movl 4(r0),_dbl_value_1+4
88 0001BE75 0d 60 efffffff74 movl (r0),_dbl_value_1
89 0001BE7C # dbl_value_2 = cmpd_1_data[index].two;
90 0001BE7C 5c 14 efffffff6d 50 mull3 $20,_index,r0
91 0001BE84 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0
92 0001BE8B 0d a004 efffffff61 movl 4(r0),_dbl_value_2+4
93 0001BE93 0d 60 efffffff56 movl (r0),_dbl_value_2
94 0001BE9A # sgl_expected = cmpd_1_data[index].flag; /* get expected results */
95 0001BE9A 5c 14 efffffff4f 50 mull3 $20,_index,r0
96 0001BEA2 0d e000000010 efffffff43 movl _cmpd_1_data+16(r0),_sgl_expected
97 0001BEAD # sgl_value_1 = dbl_value_1.m;
98 0001BEAD 0d efffffff3d efffffff38 movl _dbl_value_1,_sgl_value_1
99 0001BEB8 # sgl_value_2 = dbl_value_1.l;
100 0001BEB8 0d efffffff36 efffffff2d movl _dbl_value_1+4,_sgl_value_2
101 0001BEC3 # sgl_value_3 = dbl_value_2.m;
102 0001BEC3 0d efffffff27 efffffff22 movl _dbl_value_2,_sgl_value_3
103 0001BECE # sgl_value_4 = dbl_value_2.l;
104 0001BECE 0d efffffff20 efffffff17 movl _dbl_value_2+4,_sgl_value_4
105 0001BED9 # index2 = 0; /* clear Acc. data index */
106 0001BED9 4d efffffff11 clrl _index2
107 0001BEDF # do
108 0001BEDF L237:
109 0001BEDF # {
110 0001BEDF # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
111 0001BEDF 48 04 efffffff0a 50 shll $4,_index2,r0
112 0001BEE7 0c 8f00000000 50 addl2 $_ldd_1_data,r0
113 0001BEEE 0d a004 effffffefe movl 4(r0),_dbl_ld_acc+4
114 0001BEF6 0d 60 effffffef3 movl (r0),_dbl_ld_acc
115 0001BEFD # asm("ldd _dbl_ld_acc"); /* load the accumulator */
116 0001BEFD 07 effffffeed ldd _dbl_ld_acc
117 0001BF03 # status_index = 0; /* clear the status index */
118 0001BF03 4d effffffee7 clrl _status_index
119 0001BF09 # do
120 0001BF09 L240:
121 0001BF09 # {
122 0001BF09 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
123 0001BF09 0d effffffee1 50 movl _status_index,r0
124 0001BF10 0d 40effffffed9 movl _status_array[r0],_sgl_dummy1
effffffed4
125 0001BF1C # /*
126 0001BF1C # * If LOOP ON ERROR is set, this is the loop for this subtest.
127 0001BF1C # * The force loop flag is set after the first error.
128 0001BF1C # */
129 0001BF1C # asm("_cmpd2_1_lp1:");
130 0001BF1C _cmpd2_1_lp1:
131 0001BF1C # asm("movl _sgl_value_1,r4"); /* r4 = operand #1's MSW */
132 0001BF1C 0d effffffece 54 movl _sgl_value_1,r4
133 0001BF23 # asm("movl _sgl_value_2,r5"); /* r5 = operand #1's LSW */
134 0001BF23 0d effffffec7 55 movl _sgl_value_2,r5
135 0001BF2A # asm("movl _sgl_value_3,r6"); /* r6 = operand #2's MSW */
136 0001BF2A 0d effffffec0 56 movl _sgl_value_3,r6
137 0001BF31 # asm("movl _sgl_value_4,r7"); /* r7 = operand #2's LSW */
138 0001BF31 0d effffffeb9 57 movl _sgl_value_4,r7
139 0001BF38 # asm("nop");
140 0001BF38 10 nop
141 0001BF39 # asm("tstl _sgl_dummy1"); /* generate initial status */
142 0001BF39 5d effffffeb1 tstl _sgl_dummy1
143 0001BF3F # asm("movpsl _init_psl"); /* save the initial status */
144 0001BF3F cd effffffeab movpsl _init_psl
145 0001BF45 # asm("cmpd2 r4,r6"); /* compare the operands */
146 0001BF45 47 54 56 cmpd2 r4,r6
147 0001BF48 # asm("movpsl _psl_val"); /* save the final status */
148 0001BF48 cd effffffea2 movpsl _psl_val
149 0001BF4E # asm("std _dbl_st_acc"); /* save the acc */
150 0001BF4E 27 effffffe9c std _dbl_st_acc
151 0001BF54 # if( force_loop ) /* loop? */
152 0001BF54 5d effffffe96 tstl _force_loop
153 0001BF5A 31 02 jeql L241
154 0001BF5C # asm("brb _cmpd2_1_lp1");; /* run the loop again */
155 0001BF5C 11 be brb _cmpd2_1_lp1
156 0001BF5E L241:
157 0001BF5E # exp_psl = init_psl; /* get the initial PSL */
158 0001BF5E 0d effffffe8c effffffe87 movl _init_psl,_exp_psl
159 0001BF69 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
160 0001BF69 ac 88f3 effffffe7f andl2 $-13,_exp_psl
161 0001BF71 # if( sgl_expected == ZERO )
162 0001BF71 1d effffffe79 04 cmpl _sgl_expected,$4
163 0001BF78 21 07 jneq L242
164 0001BF7A # exp_psl |= PSL_Z; /* expect the ZERO bit set */
165 0001BF7A 8c 04 effffffe6f orl2 $4,_exp_psl
166 0001BF81 # if( sgl_expected == NEGATIVE )
167 0001BF81 L242:
168 0001BF81 1d effffffe69 08 cmpl _sgl_expected,$8
169 0001BF88 21 07 jneq L243
170 0001BF8A # exp_psl |= PSL_N; /* expect the NEG bit set */
171 0001BF8A 8c 08 effffffe5f orl2 $8,_exp_psl
172 0001BF91 # if( psl_val != exp_psl ) { /* COMPARE the values */
173 0001BF91 L243:
174 0001BF91 1d effffffe59 effffffe54 cmpl _psl_val,_exp_psl
175 0001BF9C 21 03 13 0170 jeql L244
176 0001BFA1 # errcnt++; /* bump the error count */
177 0001BFA1 6d effffffe49 incl _errcnt
178 0001BFA7 # if ( prt_error ) {
179 0001BFA7 5d effffffe43 tstl _prt_error
180 0001BFAD 21 03 13 013c jeql L245
181 0001BFB2 # writes(" \n"); /* start a new print line */
182 0001BFB2 .data 1
183 0000139f * L246:
184 0000139f * 200A00 .ascii " \12\0"
185 000013a2 * .text
186 0001BFB2 dd 8f0000139f pushl $L246
187 0001BFB8 fe 08 effffffe31 callf $8,_writes
188 0001BFBF # writes("cycle: ");
189 0001BFBF .data 1
190 000013a2 * L247:
191 000013a2 * 6379636C653A2000 .ascii "cycle: \0"
192 000013aa * .text
193 0001BFBF dd 8f000013a2 pushl $L247
194 0001BFC5 fe 08 effffffe24 callf $8,_writes
195 0001BFCC # writed( cycle );
196 0001BFCC dd effffffe1e pushl _cycle
197 0001BFD2 fe 08 effffffe17 callf $8,_writed
198 0001BFD9 # writes(" CMPD2 test ");
199 0001BFD9 .data 1
200 000013aa * L249:
201 000013aa * 2020434D50443220746573742 .ascii " CMPD2 test \0"
000
202 000013b8 * .text
203 0001BFD9 dd 8f000013aa pushl $L249
204 0001BFDF fe 08 effffffe0a callf $8,_writes
205 0001BFE6 # writed( test_no );
206 0001BFE6 dd effffffe04 pushl _test_no
207 0001BFEC fe 08 effffffdfd callf $8,_writed
208 0001BFF3 # writes(", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\n");
209 0001BFF3 .data 1
210 000013b8 * L250:
211 000013b8 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\12\0"
85265672E2F5265672E204461
746129202D204241442046494
E414C2050534C0A00
212 000013e6 * .text
213 0001BFF3 dd 8f000013b8 pushl $L250
214 0001BFF9 fe 08 effffffdf0 callf $8,_writes
215 0001C000 # print_cmpd2_data();
216 0001C000 fe 04 ef00000fcf callf $4,_print_cmpd2_data
217 0001C007 # writes(", index = ");
218 0001C007 .data 1
219 000013e6 * L252:
220 000013e6 * 2C202020696E646578203D200 .ascii ", index = \0"
0
221 000013f3 * .text
222 0001C007 dd 8f000013e6 pushl $L252
223 0001C00D fe 08 effffffddc callf $8,_writes
224 0001C014 # writed( index );
225 0001C014 dd effffffdd6 pushl _index
226 0001C01A fe 08 effffffdcf callf $8,_writed
227 0001C021 # writec('\n');
228 0001C021 dd 0a pushl $10
229 0001C023 fe 08 effffffdc6 callf $8,_writec
230 0001C02A # writes(" final Acc = ");
231 0001C02A .data 1
232 000013f3 * L254:
233 000013f3 * 20202066696E616C204163632 .ascii " final Acc = \0"
03D2000
234 00001403 * .text
235 0001C02A dd 8f000013f3 pushl $L254
236 0001C030 fe 08 effffffdb9 callf $8,_writes
237 0001C037 # write32h( dbl_st_acc.m );
238 0001C037 dd effffffdb3 pushl _dbl_st_acc
239 0001C03D fe 08 effffffdac callf $8,_write32h
240 0001C044 # writec(' ');
241 0001C044 dd 20 pushl $32
242 0001C046 fe 08 effffffda3 callf $8,_writec
243 0001C04D # write32h( dbl_st_acc.l );
244 0001C04D dd effffffda1 pushl _dbl_st_acc+4
245 0001C053 fe 08 effffffd96 callf $8,_write32h
246 0001C05A # writes(", operand 2 = ");
247 0001C05A .data 1
248 00001403 * L256:
249 00001403 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
03D2000
250 00001413 * .text
251 0001C05A dd 8f00001403 pushl $L256
252 0001C060 fe 08 effffffd89 callf $8,_writes
253 0001C067 # write32h( sgl_value_3);
254 0001C067 dd effffffd83 pushl _sgl_value_3
255 0001C06D fe 08 effffffd7c callf $8,_write32h
256 0001C074 # writec(' ');
257 0001C074 dd 20 pushl $32
258 0001C076 fe 08 effffffd73 callf $8,_writec
259 0001C07D # write32h( sgl_value_4);
260 0001C07D dd effffffd6d pushl _sgl_value_4
261 0001C083 fe 08 effffffd66 callf $8,_write32h
262 0001C08A # writec('\n');
263 0001C08A dd 0a pushl $10
264 0001C08C fe 08 effffffd5d callf $8,_writec
265 0001C093 # writes(" initial PSL = ");
266 0001C093 .data 1
267 00001413 * L257:
268 00001413 * 2020696E697469616C2050534 .ascii " initial PSL = \0"
C203D2000
269 00001424 * .text
270 0001C093 dd 8f00001413 pushl $L257
271 0001C099 fe 08 effffffd50 callf $8,_writes
272 0001C0A0 # write32h( init_psl );
273 0001C0A0 dd effffffd4a pushl _init_psl
274 0001C0A6 fe 08 effffffd43 callf $8,_write32h
275 0001C0AD # writes(", final PSL = ");
276 0001C0AD .data 1
277 00001424 * L258:
278 00001424 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
279 00001434 * .text
280 0001C0AD dd 8f00001424 pushl $L258
281 0001C0B3 fe 08 effffffd36 callf $8,_writes
282 0001C0BA # write32h( psl_val );
283 0001C0BA dd effffffd30 pushl _psl_val
284 0001C0C0 fe 08 effffffd29 callf $8,_write32h
285 0001C0C7 # writes(", expected PSL = ");
286 0001C0C7 .data 1
287 00001434 * L259:
288 00001434 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
289 00001447 * .text
290 0001C0C7 dd 8f00001434 pushl $L259
291 0001C0CD fe 08 effffffd1c callf $8,_writes
292 0001C0D4 # write32h( exp_psl );
293 0001C0D4 dd effffffd16 pushl _exp_psl
294 0001C0DA fe 08 effffffd0f callf $8,_write32h
295 0001C0E1 # writes(" \n");
296 0001C0E1 .data 1
297 00001447 * L260:
298 00001447 * 200A00 .ascii " \12\0"
299 0000144a * .text
300 0001C0E1 dd 8f00001447 pushl $L260
301 0001C0E7 fe 08 effffffd02 callf $8,_writes
302 0001C0EE # }
303 0001C0EE # if ( halt_flg )
304 0001C0EE L245:
305 0001C0EE 5d effffffcfc tstl _halt_flg
306 0001C0F4 31 09 jeql L261
307 0001C0F6 # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
308 0001C0F6 dd 03 pushl $3
309 0001C0F8 fe 08 ef00000f3f callf $8,_cmpd2_er_halt
310 0001C0FF # if ( loop_on_err ) {
311 0001C0FF L261:
312 0001C0FF 5d effffffceb tstl _loop_on_err
313 0001C105 31 0a jeql L263
314 0001C107 # force_loop = TRUE; /* set the force loop flag */
315 0001C107 0d 01 effffffce2 movl $1,_force_loop
316 0001C10E # asm("brw _cmpd2_1_lp1"); /* and loop */
317 0001C10E 13 fe0b brw _cmpd2_1_lp1
318 0001C111 # }; /* end of loop-on-error */
319 0001C111 L263:
320 0001C111 # } /* end of compare error */
321 0001C111 # } while( ++status_index < 3 );
322 0001C111 L244:
323 0001C111 L239:
324 0001C111 6d effffffcd9 incl _status_index
325 0001C117 0d effffffcd3 50 movl _status_index,r0
326 0001C11E 1d 50 03 cmpl r0,$3
327 0001C121 81 03 13 fde3 jlss L240
328 0001C126 L238:
329 0001C126 # index2++;
330 0001C126 6d effffffcc4 incl _index2
331 0001C12C # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
332 0001C12C L236:
333 0001C12C 1d effffffcbe 0a cmpl _index2,$10
334 0001C133 81 10 jgeq L9999
335 0001C135 1d effffffcb5 effffffcb0 cmpl _index2,_max_ldf_1_index
336 0001C140 81 03 13 fd9a jlss L237
337 0001C145 L9999:
338 0001C145 L235:
339 0001C145 # } while( index++ < max_cmpd_1_index );
340 0001C145 L233:
341 0001C145 0d effffffca5 50 movl _index,r0
342 0001C14C 6d effffffc9e incl _index
343 0001C152 1d 50 effffffc97 cmpl r0,_max_cmpd_1_index
344 0001C159 81 03 13 fd00 jlss L234
345 0001C15E L232:
346 0001C15E # } /* end of subtest 1 */
347 0001C15E 40 ret#2
348 0001C15F .set L228,0x0
349 0001C15F L230:
350 0001C15F 13 fce9 jbr L231
351 0001C162 .data
352 00001398 * .text
353 0001C162 .align 1
354 0001C162 .globl _cmpd2_2
355 0001C162 _cmpd2_2:
356 0001C162 0000 .word L264
357 0001C164 #
358 0001C164 #
359 0001C164 #
360 0001C164 # /****************************************************************************
361 0001C164 # *
362 0001C164 # * SUBTEST 2 - CMPD2 test - cache / cache data
363 0001C164 # *
364 0001C164 # ****************************************************************************/
365 0001C164 # cmpd2_2()
366 0001C164 # {
367 0001C164 13 0301 jbr L266
368 0001C167 L267:
369 0001C167 # force_loop = FALSE;
370 0001C167 4d effffffc83 clrl _force_loop
371 0001C16D # subtest = 2;
372 0001C16D 0d 02 effffffc7c movl $2,_subtest
373 0001C174 # index = 0;
374 0001C174 4d effffffc76 clrl _index
375 0001C17A # do
376 0001C17A L270:
377 0001C17A # {
378 0001C17A # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
379 0001C17A 5c 14 effffffc6f 50 mull3 $20,_index,r0
380 0001C182 0c 8f00000000 50 addl2 $_cmpd_1_data,r0
381 0001C189 0d a004 effffffc63 movl 4(r0),_dbl_value_1+4
382 0001C191 0d 60 effffffc58 movl (r0),_dbl_value_1
383 0001C198 # dbl_value_2 = cmpd_1_data[index].two;
384 0001C198 5c 14 effffffc51 50 mull3 $20,_index,r0
385 0001C1A0 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0
386 0001C1A7 0d a004 effffffc45 movl 4(r0),_dbl_value_2+4
387 0001C1AF 0d 60 effffffc3a movl (r0),_dbl_value_2
388 0001C1B6 # sgl_value_1 = dbl_value_1.m;
389 0001C1B6 0d effffffc34 effffffc2f movl _dbl_value_1,_sgl_value_1
390 0001C1C1 # sgl_value_2 = dbl_value_1.l;
391 0001C1C1 0d effffffc2d effffffc24 movl _dbl_value_1+4,_sgl_value_2
392 0001C1CC # sgl_value_3 = dbl_value_2.m;
393 0001C1CC 0d effffffc1e effffffc19 movl _dbl_value_2,_sgl_value_3
394 0001C1D7 # sgl_value_4 = dbl_value_2.l;
395 0001C1D7 0d effffffc17 effffffc0e movl _dbl_value_2+4,_sgl_value_4
396 0001C1E2 # sgl_expected = cmpd_1_data[index].flag; /* get expected results */
397 0001C1E2 5c 14 effffffc07 50 mull3 $20,_index,r0
398 0001C1EA 0d e000000010 effffffbfb movl _cmpd_1_data+16(r0),_sgl_expected
399 0001C1F5 # index2 = 0; /* clear Acc. data index */
400 0001C1F5 4d effffffbf5 clrl _index2
401 0001C1FB # do
402 0001C1FB L273:
403 0001C1FB # {
404 0001C1FB # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
405 0001C1FB 48 04 effffffbee 50 shll $4,_index2,r0
406 0001C203 0c 8f00000000 50 addl2 $_ldd_1_data,r0
407 0001C20A 0d a004 effffffbe2 movl 4(r0),_dbl_ld_acc+4
408 0001C212 0d 60 effffffbd7 movl (r0),_dbl_ld_acc
409 0001C219 # asm("ldd _dbl_ld_acc"); /* load the accumulator */
410 0001C219 07 effffffbd1 ldd _dbl_ld_acc
411 0001C21F # status_index = 0; /* clear the status index */
412 0001C21F 4d effffffbcb clrl _status_index
413 0001C225 # do
414 0001C225 L276:
415 0001C225 # {
416 0001C225 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
417 0001C225 0d effffffbc5 50 movl _status_index,r0
418 0001C22C 0d 40effffffbbd movl _status_array[r0],_sgl_dummy1
effffffbb8
419 0001C238 # /*
420 0001C238 # * If LOOP ON ERROR is set, this is the loop for this subtest.
421 0001C238 # * The force loop flag is set after the first error.
422 0001C238 # */
423 0001C238 # asm("_cmpd2_2_lp1:");
424 0001C238 _cmpd2_2_lp1:
425 0001C238 # asm("tstl _sgl_dummy1"); /* generate initial status */
426 0001C238 5d effffffbb2 tstl _sgl_dummy1
427 0001C23E # asm("movpsl _init_psl"); /* save the initial status */
428 0001C23E cd effffffbac movpsl _init_psl
429 0001C244 # asm("nop");
430 0001C244 10 nop
431 0001C245 # asm("cmpd2 _dbl_value_1,_dbl_value_2"); /* compare the data */
432 0001C245 47 effffffba5 effffffba0 cmpd2 _dbl_value_1,_dbl_value_2
433 0001C250 # asm("nop");
434 0001C250 10 nop
435 0001C251 # asm("movpsl _psl_val"); /* save the final status */
436 0001C251 cd effffffb99 movpsl _psl_val
437 0001C257 # asm("std _dbl_st_acc"); /* save the acc */
438 0001C257 27 effffffb93 std _dbl_st_acc
439 0001C25D # if( force_loop ) /* loop? */
440 0001C25D 5d effffffb8d tstl _force_loop
441 0001C263 31 02 jeql L277
442 0001C265 # asm("brb _cmpd2_2_lp1");; /* run the loop again */
443 0001C265 11 d1 brb _cmpd2_2_lp1
444 0001C267 L277:
445 0001C267 # exp_psl = init_psl; /* get the initial PSL */
446 0001C267 0d effffffb83 effffffb7e movl _init_psl,_exp_psl
447 0001C272 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
448 0001C272 ac 88f3 effffffb76 andl2 $-13,_exp_psl
449 0001C27A # if( sgl_expected == ZERO )
450 0001C27A 1d effffffb70 04 cmpl _sgl_expected,$4
451 0001C281 21 07 jneq L278
452 0001C283 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
453 0001C283 8c 04 effffffb66 orl2 $4,_exp_psl
454 0001C28A # if( sgl_expected == NEGATIVE )
455 0001C28A L278:
456 0001C28A 1d effffffb60 08 cmpl _sgl_expected,$8
457 0001C291 21 07 jneq L279
458 0001C293 # exp_psl |= PSL_N; /* expect the NEG bit set */
459 0001C293 8c 08 effffffb56 orl2 $8,_exp_psl
460 0001C29A # if( psl_val != exp_psl ) { /* COMPARE the values */
461 0001C29A L279:
462 0001C29A 1d effffffb50 effffffb4b cmpl _psl_val,_exp_psl
463 0001C2A5 21 03 13 0170 jeql L280
464 0001C2AA # errcnt++; /* bump the error count */
465 0001C2AA 6d effffffb40 incl _errcnt
466 0001C2B0 # if ( prt_error ) {
467 0001C2B0 5d effffffb3a tstl _prt_error
468 0001C2B6 21 03 13 013c jeql L281
469 0001C2BB # writes(" \n"); /* start a new print line */
470 0001C2BB .data 1
471 0000144a * L282:
472 0000144a * 200A00 .ascii " \12\0"
473 0000144d * .text
474 0001C2BB dd 8f0000144a pushl $L282
475 0001C2C1 fe 08 effffffb28 callf $8,_writes
476 0001C2C8 # writes("cycle: ");
477 0001C2C8 .data 1
478 0000144d * L283:
479 0000144d * 6379636C653A2000 .ascii "cycle: \0"
480 00001455 * .text
481 0001C2C8 dd 8f0000144d pushl $L283
482 0001C2CE fe 08 effffffb1b callf $8,_writes
483 0001C2D5 # writed( cycle );
484 0001C2D5 dd effffffb15 pushl _cycle
485 0001C2DB fe 08 effffffb0e callf $8,_writed
486 0001C2E2 # writes(" CMPD2 test ");
487 0001C2E2 .data 1
488 00001455 * L284:
489 00001455 * 2020434D50443220746573742 .ascii " CMPD2 test \0"
000
490 00001463 * .text
491 0001C2E2 dd 8f00001455 pushl $L284
492 0001C2E8 fe 08 effffffb01 callf $8,_writes
493 0001C2EF # writed( test_no );
494 0001C2EF dd effffffafb pushl _test_no
495 0001C2F5 fe 08 effffffaf4 callf $8,_writed
496 0001C2FC # writes(", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\n");
497 0001C2FC .data 1
498 00001463 * L285:
499 00001463 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\12\0"
843616368652F436163686520
4461746129202D20424144204
6494E414C2050534C0A00
500 00001493 * .text
501 0001C2FC dd 8f00001463 pushl $L285
502 0001C302 fe 08 effffffae7 callf $8,_writes
503 0001C309 # print_cmpd2_data();
504 0001C309 fe 04 ef00000cc6 callf $4,_print_cmpd2_data
505 0001C310 # writes(", index = ");
506 0001C310 .data 1
507 00001493 * L286:
508 00001493 * 2C202020696E646578203D200 .ascii ", index = \0"
0
509 000014a0 * .text
510 0001C310 dd 8f00001493 pushl $L286
511 0001C316 fe 08 effffffad3 callf $8,_writes
512 0001C31D # writed( index );
513 0001C31D dd effffffacd pushl _index
514 0001C323 fe 08 effffffac6 callf $8,_writed
515 0001C32A # writec('\n');
516 0001C32A dd 0a pushl $10
517 0001C32C fe 08 effffffabd callf $8,_writec
518 0001C333 # writes(" final Acc = ");
519 0001C333 .data 1
520 000014a0 * L287:
521 000014a0 * 20202066696E616C204163632 .ascii " final Acc = \0"
03D2000
522 000014b0 * .text
523 0001C333 dd 8f000014a0 pushl $L287
524 0001C339 fe 08 effffffab0 callf $8,_writes
525 0001C340 # write32h( dbl_st_acc.m );
526 0001C340 dd effffffaaa pushl _dbl_st_acc
527 0001C346 fe 08 effffffaa3 callf $8,_write32h
528 0001C34D # writec(' ');
529 0001C34D dd 20 pushl $32
530 0001C34F fe 08 effffffa9a callf $8,_writec
531 0001C356 # write32h( dbl_st_acc.l );
532 0001C356 dd effffffa98 pushl _dbl_st_acc+4
533 0001C35C fe 08 effffffa8d callf $8,_write32h
534 0001C363 # writes(", operand 2 = ");
535 0001C363 .data 1
536 000014b0 * L288:
537 000014b0 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
03D2000
538 000014c0 * .text
539 0001C363 dd 8f000014b0 pushl $L288
540 0001C369 fe 08 effffffa80 callf $8,_writes
541 0001C370 # write32h( sgl_value_3);
542 0001C370 dd effffffa7a pushl _sgl_value_3
543 0001C376 fe 08 effffffa73 callf $8,_write32h
544 0001C37D # writec(' ');
545 0001C37D dd 20 pushl $32
546 0001C37F fe 08 effffffa6a callf $8,_writec
547 0001C386 # write32h( sgl_value_4);
548 0001C386 dd effffffa64 pushl _sgl_value_4
549 0001C38C fe 08 effffffa5d callf $8,_write32h
550 0001C393 # writec('\n');
551 0001C393 dd 0a pushl $10
552 0001C395 fe 08 effffffa54 callf $8,_writec
553 0001C39C # writes(" initial PSL = ");
554 0001C39C .data 1
555 000014c0 * L289:
556 000014c0 * 2020696E697469616C2050534 .ascii " initial PSL = \0"
C203D2000
557 000014d1 * .text
558 0001C39C dd 8f000014c0 pushl $L289
559 0001C3A2 fe 08 effffffa47 callf $8,_writes
560 0001C3A9 # write32h( init_psl );
561 0001C3A9 dd effffffa41 pushl _init_psl
562 0001C3AF fe 08 effffffa3a callf $8,_write32h
563 0001C3B6 # writes(", final PSL = ");
564 0001C3B6 .data 1
565 000014d1 * L290:
566 000014d1 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
567 000014e1 * .text
568 0001C3B6 dd 8f000014d1 pushl $L290
569 0001C3BC fe 08 effffffa2d callf $8,_writes
570 0001C3C3 # write32h( psl_val );
571 0001C3C3 dd effffffa27 pushl _psl_val
572 0001C3C9 fe 08 effffffa20 callf $8,_write32h
573 0001C3D0 # writes(", expected PSL = ");
574 0001C3D0 .data 1
575 000014e1 * L291:
576 000014e1 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
577 000014f4 * .text
578 0001C3D0 dd 8f000014e1 pushl $L291
579 0001C3D6 fe 08 effffffa13 callf $8,_writes
580 0001C3DD # write32h( exp_psl );
581 0001C3DD dd effffffa0d pushl _exp_psl
582 0001C3E3 fe 08 effffffa06 callf $8,_write32h
583 0001C3EA # writes(" \n");
584 0001C3EA .data 1
585 000014f4 * L292:
586 000014f4 * 200A00 .ascii " \12\0"
587 000014f7 * .text
588 0001C3EA dd 8f000014f4 pushl $L292
589 0001C3F0 fe 08 effffff9f9 callf $8,_writes
590 0001C3F7 # }
591 0001C3F7 # if ( halt_flg )
592 0001C3F7 L281:
593 0001C3F7 5d effffff9f3 tstl _halt_flg
594 0001C3FD 31 09 jeql L293
595 0001C3FF # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
596 0001C3FF dd 03 pushl $3
597 0001C401 fe 08 ef00000c36 callf $8,_cmpd2_er_halt
598 0001C408 # if ( loop_on_err )
599 0001C408 L293:
600 0001C408 5d effffff9e2 tstl _loop_on_err
601 0001C40E 31 0a jeql L294
602 0001C410 # {
603 0001C410 # force_loop = TRUE; /* set the force loop flag */
604 0001C410 0d 01 effffff9d9 movl $1,_force_loop
605 0001C417 # asm("brw _cmpd2_2_lp1"); /* and loop */
606 0001C417 13 fe1e brw _cmpd2_2_lp1
607 0001C41A # }; /* end of loop-on-error */
608 0001C41A L294:
609 0001C41A # } /* end of compare error */
610 0001C41A # } while( ++status_index < 3 );
611 0001C41A L280:
612 0001C41A L275:
613 0001C41A 6d effffff9d0 incl _status_index
614 0001C420 0d effffff9ca 50 movl _status_index,r0
615 0001C427 1d 50 03 cmpl r0,$3
616 0001C42A 81 03 13 fdf6 jlss L276
617 0001C42F L274:
618 0001C42F # index2++;
619 0001C42F 6d effffff9bb incl _index2
620 0001C435 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
621 0001C435 L272:
622 0001C435 1d effffff9b5 0a cmpl _index2,$10
623 0001C43C 81 10 jgeq L9998
624 0001C43E 1d effffff9ac effffff9a7 cmpl _index2,_max_ldf_1_index
625 0001C449 81 03 13 fdad jlss L273
626 0001C44E L9998:
627 0001C44E L271:
628 0001C44E # } while( index++ < max_cmpd_1_index );
629 0001C44E L269:
630 0001C44E 0d effffff99c 50 movl _index,r0
631 0001C455 6d effffff995 incl _index
632 0001C45B 1d 50 effffff98e cmpl r0,_max_cmpd_1_index
633 0001C462 81 03 13 fd13 jlss L270
634 0001C467 L268:
635 0001C467 # } /* end of subtest 2 */
636 0001C467 40 ret#2
637 0001C468 .set L264,0x0
638 0001C468 L266:
639 0001C468 13 fcfc jbr L267
640 0001C46B .data
641 00001398 * .text
642 0001C46B 00 .align 1
643 0001C46C .globl _cmpd2_3
644 0001C46C _cmpd2_3:
645 0001C46C 0000 .word L295
646 0001C46E #
647 0001C46E #
648 0001C46E #
649 0001C46E # /****************************************************************************
650 0001C46E # *
651 0001C46E # * SUBTEST 3 - CMPD2 test - cache / register data
652 0001C46E # *
653 0001C46E # ****************************************************************************/
654 0001C46E # cmpd2_3()
655 0001C46E # {
656 0001C46E 13 030b jbr L297
657 0001C471 L298:
658 0001C471 # force_loop = FALSE;
659 0001C471 4d effffff979 clrl _force_loop
660 0001C477 # subtest = 3;
661 0001C477 0d 03 effffff972 movl $3,_subtest
662 0001C47E # index = 0;
663 0001C47E 4d effffff96c clrl _index
664 0001C484 # do
665 0001C484 L301:
666 0001C484 # {
667 0001C484 # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
668 0001C484 5c 14 effffff965 50 mull3 $20,_index,r0
669 0001C48C 0c 8f00000000 50 addl2 $_cmpd_1_data,r0
670 0001C493 0d a004 effffff959 movl 4(r0),_dbl_value_1+4
671 0001C49B 0d 60 effffff94e movl (r0),_dbl_value_1
672 0001C4A2 # dbl_value_2 = cmpd_1_data[index].two;
673 0001C4A2 5c 14 effffff947 50 mull3 $20,_index,r0
674 0001C4AA 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0
675 0001C4B1 0d a004 effffff93b movl 4(r0),_dbl_value_2+4
676 0001C4B9 0d 60 effffff930 movl (r0),_dbl_value_2
677 0001C4C0 # sgl_value_1 = dbl_value_1.m;
678 0001C4C0 0d effffff92a effffff925 movl _dbl_value_1,_sgl_value_1
679 0001C4CB # sgl_value_2 = dbl_value_1.l;
680 0001C4CB 0d effffff923 effffff91a movl _dbl_value_1+4,_sgl_value_2
681 0001C4D6 # sgl_value_3 = dbl_value_2.m;
682 0001C4D6 0d effffff914 effffff90f movl _dbl_value_2,_sgl_value_3
683 0001C4E1 # sgl_value_4 = dbl_value_2.l;
684 0001C4E1 0d effffff90d effffff904 movl _dbl_value_2+4,_sgl_value_4
685 0001C4EC # sgl_expected = cmpd_1_data[index].flag; /* get expected results */
686 0001C4EC 5c 14 effffff8fd 50 mull3 $20,_index,r0
687 0001C4F4 0d e000000010 effffff8f1 movl _cmpd_1_data+16(r0),_sgl_expected
688 0001C4FF # index2 = 0; /* clear Acc. data index */
689 0001C4FF 4d effffff8eb clrl _index2
690 0001C505 # do
691 0001C505 L304:
692 0001C505 # {
693 0001C505 # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
694 0001C505 48 04 effffff8e4 50 shll $4,_index2,r0
695 0001C50D 0c 8f00000000 50 addl2 $_ldd_1_data,r0
696 0001C514 0d a004 effffff8d8 movl 4(r0),_dbl_ld_acc+4
697 0001C51C 0d 60 effffff8cd movl (r0),_dbl_ld_acc
698 0001C523 # asm("ldd _dbl_ld_acc"); /* load the accumulator */
699 0001C523 07 effffff8c7 ldd _dbl_ld_acc
700 0001C529 # status_index = 0; /* clear the status index */
701 0001C529 4d effffff8c1 clrl _status_index
702 0001C52F # do
703 0001C52F L307:
704 0001C52F # {
705 0001C52F # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
706 0001C52F 0d effffff8bb 50 movl _status_index,r0
707 0001C536 0d 40effffff8b3 movl _status_array[r0],_sgl_dummy1
effffff8ae
708 0001C542 # /*
709 0001C542 # * If LOOP ON ERROR is set, this is the loop for this subtest.
710 0001C542 # * The force loop flag is set after the first error.
711 0001C542 # */
712 0001C542 # asm("_cmpd2_3_lp1:");
713 0001C542 _cmpd2_3_lp1:
714 0001C542 # asm("movl _sgl_value_3,r4"); /* move operand #2's MSW,r4 */
715 0001C542 0d effffff8a8 54 movl _sgl_value_3,r4
716 0001C549 # asm("movl _sgl_value_4,r5"); /* move operand #2's LSW,r5 */
717 0001C549 0d effffff8a1 55 movl _sgl_value_4,r5
718 0001C550 # asm("tstl _sgl_dummy1"); /* generate initial status */
719 0001C550 5d effffff89a tstl _sgl_dummy1
720 0001C556 # asm("movpsl _init_psl"); /* save the initial status */
721 0001C556 cd effffff894 movpsl _init_psl
722 0001C55C # asm("nop");
723 0001C55C 10 nop
724 0001C55D # asm("cmpd2 _dbl_value_1,r4"); /* compare the data */
725 0001C55D 47 effffff88d 54 cmpd2 _dbl_value_1,r4
726 0001C564 # asm("nop");
727 0001C564 10 nop
728 0001C565 # asm("movpsl _psl_val"); /* save the final status */
729 0001C565 cd effffff885 movpsl _psl_val
730 0001C56B # asm("std _sgl_st_acc"); /* save the acc */
731 0001C56B 27 effffff87f std _sgl_st_acc
732 0001C571 # if( force_loop ) /* loop? */
733 0001C571 5d effffff879 tstl _force_loop
734 0001C577 31 02 jeql L308
735 0001C579 # asm("brb _cmpd2_3_lp1");; /* run the loop again */
736 0001C579 11 c7 brb _cmpd2_3_lp1
737 0001C57B L308:
738 0001C57B # exp_psl = init_psl; /* get the initial PSL */
739 0001C57B 0d effffff86f effffff86a movl _init_psl,_exp_psl
740 0001C586 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
741 0001C586 ac 88f3 effffff862 andl2 $-13,_exp_psl
742 0001C58E # if( sgl_expected == ZERO )
743 0001C58E 1d effffff85c 04 cmpl _sgl_expected,$4
744 0001C595 21 07 jneq L309
745 0001C597 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
746 0001C597 8c 04 effffff852 orl2 $4,_exp_psl
747 0001C59E # if( sgl_expected == NEGATIVE )
748 0001C59E L309:
749 0001C59E 1d effffff84c 08 cmpl _sgl_expected,$8
750 0001C5A5 21 07 jneq L310
751 0001C5A7 # exp_psl |= PSL_N; /* expect the NEG bit set */
752 0001C5A7 8c 08 effffff842 orl2 $8,_exp_psl
753 0001C5AE # if( psl_val != exp_psl ) { /* COMPARE the values */
754 0001C5AE L310:
755 0001C5AE 1d effffff83c effffff837 cmpl _psl_val,_exp_psl
756 0001C5B9 21 03 13 0170 jeql L311
757 0001C5BE # errcnt++; /* bump the error count */
758 0001C5BE 6d effffff82c incl _errcnt
759 0001C5C4 # if ( prt_error ) {
760 0001C5C4 5d effffff826 tstl _prt_error
761 0001C5CA 21 03 13 013c jeql L312
762 0001C5CF # writes(" \n"); /* start a new print line */
763 0001C5CF .data 1
764 000014f7 * L313:
765 000014f7 * 200A00 .ascii " \12\0"
766 000014fa * .text
767 0001C5CF dd 8f000014f7 pushl $L313
768 0001C5D5 fe 08 effffff814 callf $8,_writes
769 0001C5DC # writes("cycle: ");
770 0001C5DC .data 1
771 000014fa * L314:
772 000014fa * 6379636C653A2000 .ascii "cycle: \0"
773 00001502 * .text
774 0001C5DC dd 8f000014fa pushl $L314
775 0001C5E2 fe 08 effffff807 callf $8,_writes
776 0001C5E9 # writed( cycle );
777 0001C5E9 dd effffff801 pushl _cycle
778 0001C5EF fe 08 effffff7fa callf $8,_writed
779 0001C5F6 # writes(" CMPD2 test ");
780 0001C5F6 .data 1
781 00001502 * L315:
782 00001502 * 2020434D50443220746573742 .ascii " CMPD2 test \0"
000
783 00001510 * .text
784 0001C5F6 dd 8f00001502 pushl $L315
785 0001C5FC fe 08 effffff7ed callf $8,_writes
786 0001C603 # writed( test_no );
787 0001C603 dd effffff7e7 pushl _test_no
788 0001C609 fe 08 effffff7e0 callf $8,_writed
789 0001C610 # writes(", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\n");
790 0001C610 .data 1
791 00001510 * L316:
792 00001510 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\12\0"
843616368652F5265672E2044
61746129202D2042414420464
94E414C2050534C0A00
793 0000153f * .text
794 0001C610 dd 8f00001510 pushl $L316
795 0001C616 fe 08 effffff7d3 callf $8,_writes
796 0001C61D # print_cmpd2_data();
797 0001C61D fe 04 ef000009b2 callf $4,_print_cmpd2_data
798 0001C624 # writes(", index = ");
799 0001C624 .data 1
800 0000153f * L317:
801 0000153f * 2C202020696E646578203D200 .ascii ", index = \0"
0
802 0000154c * .text
803 0001C624 dd 8f0000153f pushl $L317
804 0001C62A fe 08 effffff7bf callf $8,_writes
805 0001C631 # writed( index );
806 0001C631 dd effffff7b9 pushl _index
807 0001C637 fe 08 effffff7b2 callf $8,_writed
808 0001C63E # writec('\n');
809 0001C63E dd 0a pushl $10
810 0001C640 fe 08 effffff7a9 callf $8,_writec
811 0001C647 # writes(" final Acc = ");
812 0001C647 .data 1
813 0000154c * L318:
814 0000154c * 20202066696E616C204163632 .ascii " final Acc = \0"
03D2000
815 0000155c * .text
816 0001C647 dd 8f0000154c pushl $L318
817 0001C64D fe 08 effffff79c callf $8,_writes
818 0001C654 # write32h( dbl_st_acc.m );
819 0001C654 dd effffff796 pushl _dbl_st_acc
820 0001C65A fe 08 effffff78f callf $8,_write32h
821 0001C661 # writec(' ');
822 0001C661 dd 20 pushl $32
823 0001C663 fe 08 effffff786 callf $8,_writec
824 0001C66A # write32h( dbl_st_acc.l );
825 0001C66A dd effffff784 pushl _dbl_st_acc+4
826 0001C670 fe 08 effffff779 callf $8,_write32h
827 0001C677 # writes(", operand 2 = ");
828 0001C677 .data 1
829 0000155c * L319:
830 0000155c * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
03D2000
831 0000156c * .text
832 0001C677 dd 8f0000155c pushl $L319
833 0001C67D fe 08 effffff76c callf $8,_writes
834 0001C684 # write32h( sgl_value_3);
835 0001C684 dd effffff766 pushl _sgl_value_3
836 0001C68A fe 08 effffff75f callf $8,_write32h
837 0001C691 # writec(' ');
838 0001C691 dd 20 pushl $32
839 0001C693 fe 08 effffff756 callf $8,_writec
840 0001C69A # write32h( sgl_value_4);
841 0001C69A dd effffff750 pushl _sgl_value_4
842 0001C6A0 fe 08 effffff749 callf $8,_write32h
843 0001C6A7 # writec('\n');
844 0001C6A7 dd 0a pushl $10
845 0001C6A9 fe 08 effffff740 callf $8,_writec
846 0001C6B0 # writes(" initial PSL = ");
847 0001C6B0 .data 1
848 0000156c * L320:
849 0000156c * 2020696E697469616C2050534 .ascii " initial PSL = \0"
C203D2000
850 0000157d * .text
851 0001C6B0 dd 8f0000156c pushl $L320
852 0001C6B6 fe 08 effffff733 callf $8,_writes
853 0001C6BD # write32h( init_psl );
854 0001C6BD dd effffff72d pushl _init_psl
855 0001C6C3 fe 08 effffff726 callf $8,_write32h
856 0001C6CA # writes(", final PSL = ");
857 0001C6CA .data 1
858 0000157d * L321:
859 0000157d * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
860 0000158d * .text
861 0001C6CA dd 8f0000157d pushl $L321
862 0001C6D0 fe 08 effffff719 callf $8,_writes
863 0001C6D7 # write32h( psl_val );
864 0001C6D7 dd effffff713 pushl _psl_val
865 0001C6DD fe 08 effffff70c callf $8,_write32h
866 0001C6E4 # writes(", expected PSL = ");
867 0001C6E4 .data 1
868 0000158d * L322:
869 0000158d * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
870 000015a0 * .text
871 0001C6E4 dd 8f0000158d pushl $L322
872 0001C6EA fe 08 effffff6ff callf $8,_writes
873 0001C6F1 # write32h( exp_psl );
874 0001C6F1 dd effffff6f9 pushl _exp_psl
875 0001C6F7 fe 08 effffff6f2 callf $8,_write32h
876 0001C6FE # writes(" \n");
877 0001C6FE .data 1
878 000015a0 * L323:
879 000015a0 * 200A00 .ascii " \12\0"
880 000015a3 * .text
881 0001C6FE dd 8f000015a0 pushl $L323
882 0001C704 fe 08 effffff6e5 callf $8,_writes
883 0001C70B # }
884 0001C70B # if ( halt_flg )
885 0001C70B L312:
886 0001C70B 5d effffff6df tstl _halt_flg
887 0001C711 31 09 jeql L324
888 0001C713 # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
889 0001C713 dd 03 pushl $3
890 0001C715 fe 08 ef00000922 callf $8,_cmpd2_er_halt
891 0001C71C # if ( loop_on_err )
892 0001C71C L324:
893 0001C71C 5d effffff6ce tstl _loop_on_err
894 0001C722 31 0a jeql L325
895 0001C724 # {
896 0001C724 # force_loop = TRUE; /* set the force loop flag */
897 0001C724 0d 01 effffff6c5 movl $1,_force_loop
898 0001C72B # asm("brw _cmpd2_3_lp1"); /* and loop */
899 0001C72B 13 fe14 brw _cmpd2_3_lp1
900 0001C72E # }; /* end of loop-on-error */
901 0001C72E L325:
902 0001C72E # } /* end of compare error */
903 0001C72E # } while( ++status_index < 3 );
904 0001C72E L311:
905 0001C72E L306:
906 0001C72E 6d effffff6bc incl _status_index
907 0001C734 0d effffff6b6 50 movl _status_index,r0
908 0001C73B 1d 50 03 cmpl r0,$3
909 0001C73E 81 03 13 fdec jlss L307
910 0001C743 L305:
911 0001C743 # index2++;
912 0001C743 6d effffff6a7 incl _index2
913 0001C749 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
914 0001C749 L303:
915 0001C749 1d effffff6a1 0a cmpl _index2,$10
916 0001C750 81 10 jgeq L9997
917 0001C752 1d effffff698 effffff693 cmpl _index2,_max_ldf_1_index
918 0001C75D 81 03 13 fda3 jlss L304
919 0001C762 L9997:
920 0001C762 L302:
921 0001C762 # } while( index++ < max_cmpd_1_index );
922 0001C762 L300:
923 0001C762 0d effffff688 50 movl _index,r0
924 0001C769 6d effffff681 incl _index
925 0001C76F 1d 50 effffff67a cmpl r0,_max_cmpd_1_index
926 0001C776 81 03 13 fd09 jlss L301
927 0001C77B L299:
928 0001C77B # } /* end of subtest 3 */
929 0001C77B 40 ret#2
930 0001C77C .set L295,0x0
931 0001C77C L297:
932 0001C77C 13 fcf2 jbr L298
933 0001C77F .data
934 00001398 * .text
935 0001C77F 00 .align 1
936 0001C780 .globl _cmpd2_4
937 0001C780 _cmpd2_4:
938 0001C780 0000 .word L326
939 0001C782 #
940 0001C782 #
941 0001C782 #
942 0001C782 # /****************************************************************************
943 0001C782 # *
944 0001C782 # * SUBTEST 4 - CMPD2 test - register / cache data
945 0001C782 # *
946 0001C782 # ****************************************************************************/
947 0001C782 # cmpd2_4()
948 0001C782 # {
949 0001C782 13 030e jbr L328
950 0001C785 L329:
951 0001C785 # force_loop = FALSE;
952 0001C785 4d effffff665 clrl _force_loop
953 0001C78B # subtest = 4;
954 0001C78B 0d 04 effffff65e movl $4,_subtest
955 0001C792 # index = 0;
956 0001C792 4d effffff658 clrl _index
957 0001C798 # do
958 0001C798 L332:
959 0001C798 # {
960 0001C798 # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
961 0001C798 5c 14 effffff651 50 mull3 $20,_index,r0
962 0001C7A0 0c 8f00000000 50 addl2 $_cmpd_1_data,r0
963 0001C7A7 0d a004 effffff645 movl 4(r0),_dbl_value_1+4
964 0001C7AF 0d 60 effffff63a movl (r0),_dbl_value_1
965 0001C7B6 # dbl_value_2 = cmpd_1_data[index].two;
966 0001C7B6 5c 14 effffff633 50 mull3 $20,_index,r0
967 0001C7BE 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0
968 0001C7C5 0d a004 effffff627 movl 4(r0),_dbl_value_2+4
969 0001C7CD 0d 60 effffff61c movl (r0),_dbl_value_2
970 0001C7D4 # sgl_value_1 = dbl_value_1.m;
971 0001C7D4 0d effffff616 effffff611 movl _dbl_value_1,_sgl_value_1
972 0001C7DF # sgl_value_2 = dbl_value_1.l;
973 0001C7DF 0d effffff60f effffff606 movl _dbl_value_1+4,_sgl_value_2
974 0001C7EA # sgl_value_3 = dbl_value_2.m;
975 0001C7EA 0d effffff600 effffff5fb movl _dbl_value_2,_sgl_value_3
976 0001C7F5 # sgl_value_4 = dbl_value_2.l;
977 0001C7F5 0d effffff5f9 effffff5f0 movl _dbl_value_2+4,_sgl_value_4
978 0001C800 # sgl_expected = cmpd_1_data[index].flag; /* get expected results */
979 0001C800 5c 14 effffff5e9 50 mull3 $20,_index,r0
980 0001C808 0d e000000010 effffff5dd movl _cmpd_1_data+16(r0),_sgl_expected
981 0001C813 # index2 = 0; /* clear Acc. data index */
982 0001C813 4d effffff5d7 clrl _index2
983 0001C819 # do
984 0001C819 L335:
985 0001C819 # {
986 0001C819 # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
987 0001C819 48 04 effffff5d0 50 shll $4,_index2,r0
988 0001C821 0c 8f00000000 50 addl2 $_ldd_1_data,r0
989 0001C828 0d a004 effffff5c4 movl 4(r0),_dbl_ld_acc+4
990 0001C830 0d 60 effffff5b9 movl (r0),_dbl_ld_acc
991 0001C837 # asm("ldd _dbl_ld_acc"); /* load the accumulator */
992 0001C837 07 effffff5b3 ldd _dbl_ld_acc
993 0001C83D # status_index = 0; /* clear the status index */
994 0001C83D 4d effffff5ad clrl _status_index
995 0001C843 # do
996 0001C843 L338:
997 0001C843 # {
998 0001C843 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
999 0001C843 0d effffff5a7 50 movl _status_index,r0
1000 0001C84A 0d 40effffff59f movl _status_array[r0],_sgl_dummy1
effffff59a
1001 0001C856 # /*
1002 0001C856 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1003 0001C856 # * The force loop flag is set after the first error.
1004 0001C856 # */
1005 0001C856 # asm("_cmpd2_4_lp1:");
1006 0001C856 _cmpd2_4_lp1:
1007 0001C856 # asm("movl _sgl_value_1,r2"); /* move operand #1,s MSW,r2 */
1008 0001C856 0d effffff594 52 movl _sgl_value_1,r2
1009 0001C85D # asm("movl _sgl_value_2,r3"); /* move operand #1's LSW,r3 */
1010 0001C85D 0d effffff58d 53 movl _sgl_value_2,r3
1011 0001C864 # asm("tstl _sgl_dummy1"); /* generate initial status */
1012 0001C864 5d effffff586 tstl _sgl_dummy1
1013 0001C86A # asm("movpsl _init_psl"); /* save the initial status */
1014 0001C86A cd effffff580 movpsl _init_psl
1015 0001C870 # asm("nop");
1016 0001C870 10 nop
1017 0001C871 # asm("cmpd2 r2,_dbl_value_2"); /* compare the data */
1018 0001C871 47 52 effffff578 cmpd2 r2,_dbl_value_2
1019 0001C878 # asm("nop");
1020 0001C878 10 nop
1021 0001C879 # asm("movpsl _psl_val"); /* save the final status */
1022 0001C879 cd effffff571 movpsl _psl_val
1023 0001C87F # asm("std _dbl_st_acc"); /* save the acc */
1024 0001C87F 27 effffff56b std _dbl_st_acc
1025 0001C885 # if( force_loop ) /* loop? */
1026 0001C885 5d effffff565 tstl _force_loop
1027 0001C88B 31 02 jeql L339
1028 0001C88D # asm("brb _cmpd2_4_lp1");; /* run the loop again */
1029 0001C88D 11 c7 brb _cmpd2_4_lp1
1030 0001C88F L339:
1031 0001C88F # exp_psl = init_psl; /* get the initial PSL */
1032 0001C88F 0d effffff55b effffff556 movl _init_psl,_exp_psl
1033 0001C89A # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
1034 0001C89A ac 88f3 effffff54e andl2 $-13,_exp_psl
1035 0001C8A2 # if( sgl_expected == ZERO )
1036 0001C8A2 1d effffff548 04 cmpl _sgl_expected,$4
1037 0001C8A9 21 07 jneq L340
1038 0001C8AB # exp_psl |= PSL_Z; /* expect the ZERO bit set */
1039 0001C8AB 8c 04 effffff53e orl2 $4,_exp_psl
1040 0001C8B2 # if( sgl_expected == NEGATIVE )
1041 0001C8B2 L340:
1042 0001C8B2 1d effffff538 08 cmpl _sgl_expected,$8
1043 0001C8B9 21 07 jneq L341
1044 0001C8BB # exp_psl |= PSL_N; /* expect the NEG bit set */
1045 0001C8BB 8c 08 effffff52e orl2 $8,_exp_psl
1046 0001C8C2 # if( psl_val != exp_psl ) { /* COMPARE the values */
1047 0001C8C2 L341:
1048 0001C8C2 1d effffff528 effffff523 cmpl _psl_val,_exp_psl
1049 0001C8CD 21 03 13 0173 jeql L342
1050 0001C8D2 # errcnt++; /* bump the error count */
1051 0001C8D2 6d effffff518 incl _errcnt
1052 0001C8D8 # if ( prt_error ) {
1053 0001C8D8 5d effffff512 tstl _prt_error
1054 0001C8DE 21 03 13 013c jeql L343
1055 0001C8E3 # writes(" \n"); /* start a new print line */
1056 0001C8E3 .data 1
1057 000015a3 * L344:
1058 000015a3 * 200A00 .ascii " \12\0"
1059 000015a6 * .text
1060 0001C8E3 dd 8f000015a3 pushl $L344
1061 0001C8E9 fe 08 effffff500 callf $8,_writes
1062 0001C8F0 # writes("cycle: ");
1063 0001C8F0 .data 1
1064 000015a6 * L345:
1065 000015a6 * 6379636C653A2000 .ascii "cycle: \0"
1066 000015ae * .text
1067 0001C8F0 dd 8f000015a6 pushl $L345
1068 0001C8F6 fe 08 effffff4f3 callf $8,_writes
1069 0001C8FD # writed( cycle );
1070 0001C8FD dd effffff4ed pushl _cycle
1071 0001C903 fe 08 effffff4e6 callf $8,_writed
1072 0001C90A # writes(" CMPD2 test ");
1073 0001C90A .data 1
1074 000015ae * L346:
1075 000015ae * 2020434D50443220746573742 .ascii " CMPD2 test \0"
000
1076 000015bc * .text
1077 0001C90A dd 8f000015ae pushl $L346
1078 0001C910 fe 08 effffff4d9 callf $8,_writes
1079 0001C917 # writed( test_no );
1080 0001C917 dd effffff4d3 pushl _test_no
1081 0001C91D fe 08 effffff4cc callf $8,_writed
1082 0001C924 # writes(", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\n");
1083 0001C924 .data 1
1084 000015bc * L347:
1085 000015bc * 2C20737562746573742034202 .ascii ", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\12\0"
85265672E2F43616368652044
61746129202D2042414420464
94E414C2050534C0A00
1086 000015eb * .text
1087 0001C924 dd 8f000015bc pushl $L347
1088 0001C92A fe 08 effffff4bf callf $8,_writes
1089 0001C931 # print_cmpd2_data();
1090 0001C931 fe 04 ef0000069e callf $4,_print_cmpd2_data
1091 0001C938 # writes(", index = ");
1092 0001C938 .data 1
1093 000015eb * L348:
1094 000015eb * 2C202020696E646578203D200 .ascii ", index = \0"
0
1095 000015f8 * .text
1096 0001C938 dd 8f000015eb pushl $L348
1097 0001C93E fe 08 effffff4ab callf $8,_writes
1098 0001C945 # writed( index );
1099 0001C945 dd effffff4a5 pushl _index
1100 0001C94B fe 08 effffff49e callf $8,_writed
1101 0001C952 # writec('\n');
1102 0001C952 dd 0a pushl $10
1103 0001C954 fe 08 effffff495 callf $8,_writec
1104 0001C95B # writes(" final Acc = ");
1105 0001C95B .data 1
1106 000015f8 * L349:
1107 000015f8 * 20202066696E616C204163632 .ascii " final Acc = \0"
03D2000
1108 00001608 * .text
1109 0001C95B dd 8f000015f8 pushl $L349
1110 0001C961 fe 08 effffff488 callf $8,_writes
1111 0001C968 # write32h( dbl_st_acc.m );
1112 0001C968 dd effffff482 pushl _dbl_st_acc
1113 0001C96E fe 08 effffff47b callf $8,_write32h
1114 0001C975 # writec(' ');
1115 0001C975 dd 20 pushl $32
1116 0001C977 fe 08 effffff472 callf $8,_writec
1117 0001C97E # write32h( dbl_st_acc.l );
1118 0001C97E dd effffff470 pushl _dbl_st_acc+4
1119 0001C984 fe 08 effffff465 callf $8,_write32h
1120 0001C98B # writes(", operand 2 = ");
1121 0001C98B .data 1
1122 00001608 * L350:
1123 00001608 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
03D2000
1124 00001618 * .text
1125 0001C98B dd 8f00001608 pushl $L350
1126 0001C991 fe 08 effffff458 callf $8,_writes
1127 0001C998 # write32h( sgl_value_3);
1128 0001C998 dd effffff452 pushl _sgl_value_3
1129 0001C99E fe 08 effffff44b callf $8,_write32h
1130 0001C9A5 # writec(' ');
1131 0001C9A5 dd 20 pushl $32
1132 0001C9A7 fe 08 effffff442 callf $8,_writec
1133 0001C9AE # write32h( sgl_value_4);
1134 0001C9AE dd effffff43c pushl _sgl_value_4
1135 0001C9B4 fe 08 effffff435 callf $8,_write32h
1136 0001C9BB # writec('\n');
1137 0001C9BB dd 0a pushl $10
1138 0001C9BD fe 08 effffff42c callf $8,_writec
1139 0001C9C4 # writes(" initial PSL = ");
1140 0001C9C4 .data 1
1141 00001618 * L351:
1142 00001618 * 2020696E697469616C2050534 .ascii " initial PSL = \0"
C203D2000
1143 00001629 * .text
1144 0001C9C4 dd 8f00001618 pushl $L351
1145 0001C9CA fe 08 effffff41f callf $8,_writes
1146 0001C9D1 # write32h( init_psl );
1147 0001C9D1 dd effffff419 pushl _init_psl
1148 0001C9D7 fe 08 effffff412 callf $8,_write32h
1149 0001C9DE # writes(", final PSL = ");
1150 0001C9DE .data 1
1151 00001629 * L352:
1152 00001629 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
1153 00001639 * .text
1154 0001C9DE dd 8f00001629 pushl $L352
1155 0001C9E4 fe 08 effffff405 callf $8,_writes
1156 0001C9EB # write32h( psl_val );
1157 0001C9EB dd effffff3ff pushl _psl_val
1158 0001C9F1 fe 08 effffff3f8 callf $8,_write32h
1159 0001C9F8 # writes(", expected PSL = ");
1160 0001C9F8 .data 1
1161 00001639 * L353:
1162 00001639 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
1163 0000164c * .text
1164 0001C9F8 dd 8f00001639 pushl $L353
1165 0001C9FE fe 08 effffff3eb callf $8,_writes
1166 0001CA05 # write32h( exp_psl );
1167 0001CA05 dd effffff3e5 pushl _exp_psl
1168 0001CA0B fe 08 effffff3de callf $8,_write32h
1169 0001CA12 # writes(" \n");
1170 0001CA12 .data 1
1171 0000164c * L354:
1172 0000164c * 200A00 .ascii " \12\0"
1173 0000164f * .text
1174 0001CA12 dd 8f0000164c pushl $L354
1175 0001CA18 fe 08 effffff3d1 callf $8,_writes
1176 0001CA1F # }
1177 0001CA1F # if ( halt_flg )
1178 0001CA1F L343:
1179 0001CA1F 5d effffff3cb tstl _halt_flg
1180 0001CA25 31 09 jeql L355
1181 0001CA27 # cmpd2_er_halt( BAD_PSL_HLT ); /* halt on the error */
1182 0001CA27 dd 03 pushl $3
1183 0001CA29 fe 08 ef0000060e callf $8,_cmpd2_er_halt
1184 0001CA30 # if ( loop_on_err )
1185 0001CA30 L355:
1186 0001CA30 5d effffff3ba tstl _loop_on_err
1187 0001CA36 31 0d jeql L356
1188 0001CA38 # {
1189 0001CA38 # force_loop = TRUE; /* set the force loop flag */
1190 0001CA38 0d 01 effffff3b1 movl $1,_force_loop
1191 0001CA3F # asm("jmp _cmpd2_4_lp1"); /* and loop */
1192 0001CA3F 71 effffffe11 jmp _cmpd2_4_lp1
1193 0001CA45 # } /* end of loop-on-error */
1194 0001CA45 # } /* end of compare error */
1195 0001CA45 L356:
1196 0001CA45 # } while( ++status_index < 3 ); /* end of status loop */
1197 0001CA45 L342:
1198 0001CA45 L337:
1199 0001CA45 6d effffff3a5 incl _status_index
1200 0001CA4B 0d effffff39f 50 movl _status_index,r0
1201 0001CA52 1d 50 03 cmpl r0,$3
1202 0001CA55 81 03 13 fde9 jlss L338
1203 0001CA5A L336:
1204 0001CA5A # index2++;
1205 0001CA5A 6d effffff390 incl _index2
1206 0001CA60 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
1207 0001CA60 L334:
1208 0001CA60 1d effffff38a 0a cmpl _index2,$10
1209 0001CA67 81 10 jgeq L9996
1210 0001CA69 1d effffff381 effffff37c cmpl _index2,_max_ldf_1_index
1211 0001CA74 81 03 13 fda0 jlss L335
1212 0001CA79 L9996:
1213 0001CA79 L333:
1214 0001CA79 # } while( index++ < max_cmpd_1_index );
1215 0001CA79 L331:
1216 0001CA79 0d effffff371 50 movl _index,r0
1217 0001CA80 6d effffff36a incl _index
1218 0001CA86 1d 50 effffff363 cmpl r0,_max_cmpd_1_index
1219 0001CA8D 81 03 13 fd06 jlss L332
1220 0001CA92 L330:
1221 0001CA92 # } /* end of subtest 4 */
1222 0001CA92 40 ret#2
1223 0001CA93 .set L326,0x0
1224 0001CA93 L328:
1225 0001CA93 13 fcef jbr L329
1226 0001CA96 .data
1227 00001398 * .text
1228 0001CA96 .align 1
1229 0001CA96 .globl _cmpd2_5
1230 0001CA96 _cmpd2_5:
1231 0001CA96 0000 .word L357
1232 0001CA98 #
1233 0001CA98 #
1234 0001CA98 #
1235 0001CA98 # /************************************************************************
1236 0001CA98 # *
1237 0001CA98 # * SUBTEST 5 - Check for register corruption
1238 0001CA98 # *
1239 0001CA98 # ************************************************************************/
1240 0001CA98 # cmpd2_5()
1241 0001CA98 # {
1242 0001CA98 13 0296 jbr L359
1243 0001CA9B L360:
1244 0001CA9B # force_loop = FALSE; /* clear force_loop flg */
1245 0001CA9B 4d effffff34f clrl _force_loop
1246 0001CAA1 # subtest = 5;
1247 0001CAA1 0d 05 effffff348 movl $5,_subtest
1248 0001CAA8 # fill_reg_buf( load_regs ); /* get pattern for regs */
1249 0001CAA8 dd 8f00000000 pushl $_load_regs
1250 0001CAAE fe 08 effffff33b callf $8,_fill_reg_buf
1251 0001CAB5 # index = 0;
1252 0001CAB5 4d effffff335 clrl _index
1253 0001CABB # do
1254 0001CABB L364:
1255 0001CABB # {
1256 0001CABB # dbl_value_1 = cmpd_1_data[index].one; /* data to load */
1257 0001CABB 5c 14 effffff32e 50 mull3 $20,_index,r0
1258 0001CAC3 0c 8f00000000 50 addl2 $_cmpd_1_data,r0
1259 0001CACA 0d a004 effffff322 movl 4(r0),_dbl_value_1+4
1260 0001CAD2 0d 60 effffff317 movl (r0),_dbl_value_1
1261 0001CAD9 # dbl_value_2 = cmpd_1_data[index].two; /* data to compare */
1262 0001CAD9 5c 14 effffff310 50 mull3 $20,_index,r0
1263 0001CAE1 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0
1264 0001CAE8 0d a004 effffff304 movl 4(r0),_dbl_value_2+4
1265 0001CAF0 0d 60 effffff2f9 movl (r0),_dbl_value_2
1266 0001CAF7 # dbl_ld_acc.m = 0x40800000; /* get acc data */
1267 0001CAF7 0d 8f40800000 effffff2ee movl $1082130432,_dbl_ld_acc
1268 0001CB02 # dbl_ld_acc.l = 0x10101010; /* get acc data */
1269 0001CB02 0d 8f10101010 effffff2e7 movl $269488144,_dbl_ld_acc+4
1270 0001CB0D # sgl_value_1 = dbl_value_1.m;
1271 0001CB0D 0d effffff2dd effffff2d8 movl _dbl_value_1,_sgl_value_1
1272 0001CB18 # sgl_value_2 = dbl_value_1.l;
1273 0001CB18 0d effffff2d6 effffff2cd movl _dbl_value_1+4,_sgl_value_2
1274 0001CB23 # sgl_value_3 = dbl_value_2.m;
1275 0001CB23 0d effffff2c7 effffff2c2 movl _dbl_value_2,_sgl_value_3
1276 0001CB2E # sgl_value_4 = dbl_value_2.l;
1277 0001CB2E 0d effffff2c0 effffff2b7 movl _dbl_value_2+4,_sgl_value_4
1278 0001CB39 # asm("ldd _dbl_ld_acc"); /* load the acc */
1279 0001CB39 07 effffff2b1 ldd _dbl_ld_acc
1280 0001CB3F # /*
1281 0001CB3F # * If LOOP ON ERROR is set, this is the loop for this subtest.
1282 0001CB3F # * The force loop flag is set after the first error.
1283 0001CB3F # */
1284 0001CB3F # asm("_cmpd2_5_lp1:");
1285 0001CB3F _cmpd2_5_lp1:
1286 0001CB3F # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
1287 0001CB3F ab 891fff effffff2a8 loadr $0x1fff,_load_regs
1288 0001CB48 # asm("nop");
1289 0001CB48 10 nop
1290 0001CB49 # asm("cmpd2 _dbl_value_1,_dbl_value_2"); /* compare the data */
1291 0001CB49 47 effffff2a1 effffff29c cmpd2 _dbl_value_1,_dbl_value_2
1292 0001CB54 # asm("nop");
1293 0001CB54 10 nop
1294 0001CB55 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
1295 0001CB55 bb 891fff effffff292 storer $0x1fff,_store_regs
1296 0001CB5E # asm("std _dbl_st_acc"); /* save the acc */
1297 0001CB5E 27 effffff28c std _dbl_st_acc
1298 0001CB64 # if( force_loop ) /* loop? */
1299 0001CB64 5d effffff286 tstl _force_loop
1300 0001CB6A 31 02 jeql L365
1301 0001CB6C # asm("brb _cmpd2_5_lp1");; /* run the loop again */
1302 0001CB6C 11 d1 brb _cmpd2_5_lp1
1303 0001CB6E L365:
1304 0001CB6E # /*
1305 0001CB6E # * Now compare the stored register values to those that were loaded
1306 0001CB6E # */
1307 0001CB6E # index2 = 0;
1308 0001CB6E 4d effffff27c clrl _index2
1309 0001CB74 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
1310 0001CB74 L366:
1311 0001CB74 0d effffff276 50 movl _index2,r0
1312 0001CB7B 0d effffff26f 51 movl _index2,r1
1313 0001CB82 1d 40effffff267 cmpl _load_regs[r0],_store_regs[r1]
41effffff261
1314 0001CB8F 21 11 jneq L367
1315 0001CB91 1d effffff259 0d cmpl _index2,$13
1316 0001CB98 81 08 jgeq L367
1317 0001CB9A # index2++; /* check reg values */
1318 0001CB9A 6d effffff250 incl _index2
1319 0001CBA0 11 d2 jbr L366
1320 0001CBA2 L367:
1321 0001CBA2 # if( index2 < 13 ) { /* error if index2 < 13 */
1322 0001CBA2 1d effffff248 0d cmpl _index2,$13
1323 0001CBA9 91 03 13 0169 jgeq L368
1324 0001CBAE # errcnt++; /* bump the error count */
1325 0001CBAE 6d effffff23c incl _errcnt
1326 0001CBB4 # if ( prt_error ) {
1327 0001CBB4 5d effffff236 tstl _prt_error
1328 0001CBBA 21 03 13 0132 jeql L369
1329 0001CBBF # writes(" \n"); /* start a new print line */
1330 0001CBBF .data 1
1331 0000164f * L370:
1332 0000164f * 200A00 .ascii " \12\0"
1333 00001652 * .text
1334 0001CBBF dd 8f0000164f pushl $L370
1335 0001CBC5 fe 08 effffff224 callf $8,_writes
1336 0001CBCC # writes("cycle: ");
1337 0001CBCC .data 1
1338 00001652 * L371:
1339 00001652 * 6379636C653A2000 .ascii "cycle: \0"
1340 0000165a * .text
1341 0001CBCC dd 8f00001652 pushl $L371
1342 0001CBD2 fe 08 effffff217 callf $8,_writes
1343 0001CBD9 # writed( cycle );
1344 0001CBD9 dd effffff211 pushl _cycle
1345 0001CBDF fe 08 effffff20a callf $8,_writed
1346 0001CBE6 # writes(", CMPD2 test ");
1347 0001CBE6 .data 1
1348 0000165a * L372:
1349 0000165a * 2C20434D50443220746573742 .ascii ", CMPD2 test \0"
000
1350 00001668 * .text
1351 0001CBE6 dd 8f0000165a pushl $L372
1352 0001CBEC fe 08 effffff1fd callf $8,_writes
1353 0001CBF3 # writed( test_no );
1354 0001CBF3 dd effffff1f7 pushl _test_no
1355 0001CBF9 fe 08 effffff1f0 callf $8,_writed
1356 0001CC00 # writes(", subtest 5 - A REGISTER WAS MODIFIED\n");
1357 0001CC00 .data 1
1358 00001668 * L373:
1359 00001668 * 2C20737562746573742035202 .ascii ", subtest 5 - A REGISTER WAS MODIFIED\12\0"
D204120524547495354455220
574153204D4F4449464945440
A00
1360 0000168f * .text
1361 0001CC00 dd 8f00001668 pushl $L373
1362 0001CC06 fe 08 effffff1e3 callf $8,_writes
1363 0001CC0D # print_cmpd2_data();
1364 0001CC0D fe 04 ef000003c2 callf $4,_print_cmpd2_data
1365 0001CC14 # writec('\n');
1366 0001CC14 dd 0a pushl $10
1367 0001CC16 fe 08 effffff1d3 callf $8,_writec
1368 0001CC1D # writes(" final Acc = ");
1369 0001CC1D .data 1
1370 0000168f * L374:
1371 0000168f * 20202066696E616C204163632 .ascii " final Acc = \0"
03D2000
1372 0000169f * .text
1373 0001CC1D dd 8f0000168f pushl $L374
1374 0001CC23 fe 08 effffff1c6 callf $8,_writes
1375 0001CC2A # write32h( dbl_st_acc.m );
1376 0001CC2A dd effffff1c0 pushl _dbl_st_acc
1377 0001CC30 fe 08 effffff1b9 callf $8,_write32h
1378 0001CC37 # writec(' ');
1379 0001CC37 dd 20 pushl $32
1380 0001CC39 fe 08 effffff1b0 callf $8,_writec
1381 0001CC40 # write32h( dbl_st_acc.l );
1382 0001CC40 dd effffff1ae pushl _dbl_st_acc+4
1383 0001CC46 fe 08 effffff1a3 callf $8,_write32h
1384 0001CC4D # writes(", operand 2 = ");
1385 0001CC4D .data 1
1386 0000169f * L375:
1387 0000169f * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
03D2000
1388 000016af * .text
1389 0001CC4D dd 8f0000169f pushl $L375
1390 0001CC53 fe 08 effffff196 callf $8,_writes
1391 0001CC5A # write32h( sgl_value_3);
1392 0001CC5A dd effffff190 pushl _sgl_value_3
1393 0001CC60 fe 08 effffff189 callf $8,_write32h
1394 0001CC67 # writec(' ');
1395 0001CC67 dd 20 pushl $32
1396 0001CC69 fe 08 effffff180 callf $8,_writec
1397 0001CC70 # write32h( sgl_value_4);
1398 0001CC70 dd effffff17a pushl _sgl_value_4
1399 0001CC76 fe 08 effffff173 callf $8,_write32h
1400 0001CC7D # writec('\n');
1401 0001CC7D dd 0a pushl $10
1402 0001CC7F fe 08 effffff16a callf $8,_writec
1403 0001CC86 # writes("register ");
1404 0001CC86 .data 1
1405 000016af * L376:
1406 000016af * 72656769737465722000 .ascii "register \0"
1407 000016b9 * .text
1408 0001CC86 dd 8f000016af pushl $L376
1409 0001CC8C fe 08 effffff15d callf $8,_writes
1410 0001CC93 # writed( index2 );
1411 0001CC93 dd effffff157 pushl _index2
1412 0001CC99 fe 08 effffff150 callf $8,_writed
1413 0001CCA0 # writes(" = ");
1414 0001CCA0 .data 1
1415 000016b9 * L377:
1416 000016b9 * 203D2000 .ascii " = \0"
1417 000016bd * .text
1418 0001CCA0 dd 8f000016b9 pushl $L377
1419 0001CCA6 fe 08 effffff143 callf $8,_writes
1420 0001CCAD # write32h( store_regs[ index2 ] );
1421 0001CCAD 0d effffff13d 50 movl _index2,r0
1422 0001CCB4 dd 40effffff135 pushl _store_regs[r0]
1423 0001CCBB fe 08 effffff12e callf $8,_write32h
1424 0001CCC2 # writes(", should be = ");
1425 0001CCC2 .data 1
1426 000016bd * L378:
1427 000016bd * 2C202073686F756C642062652 .ascii ", should be = \0"
03D2000
1428 000016cd * .text
1429 0001CCC2 dd 8f000016bd pushl $L378
1430 0001CCC8 fe 08 effffff121 callf $8,_writes
1431 0001CCCF # write32h( load_regs[ index2 ] );
1432 0001CCCF 0d effffff11b 50 movl _index2,r0
1433 0001CCD6 dd 40effffff113 pushl _load_regs[r0]
1434 0001CCDD fe 08 effffff10c callf $8,_write32h
1435 0001CCE4 # writes("\n");
1436 0001CCE4 .data 1
1437 000016cd * L379:
1438 000016cd * 0A00 .ascii "\12\0"
1439 000016cf * .text
1440 0001CCE4 dd 8f000016cd pushl $L379
1441 0001CCEA fe 08 effffff0ff callf $8,_writes
1442 0001CCF1 # }
1443 0001CCF1 # if ( halt_flg )
1444 0001CCF1 L369:
1445 0001CCF1 5d effffff0f9 tstl _halt_flg
1446 0001CCF7 31 09 jeql L380
1447 0001CCF9 # cmpd2_er_halt( BAD_REG_HLT ); /* halt on the error */
1448 0001CCF9 dd 02 pushl $2
1449 0001CCFB fe 08 ef0000033c callf $8,_cmpd2_er_halt
1450 0001CD02 # if ( loop_on_err )
1451 0001CD02 L380:
1452 0001CD02 5d effffff0e8 tstl _loop_on_err
1453 0001CD08 31 0d jeql L381
1454 0001CD0A # {
1455 0001CD0A # force_loop = TRUE; /* set the force loop flag */
1456 0001CD0A 0d 01 effffff0df movl $1,_force_loop
1457 0001CD11 # asm("jmp _cmpd2_5_lp1"); /* and loop */
1458 0001CD11 71 effffffe28 jmp _cmpd2_5_lp1
1459 0001CD17 # }; /* end of loop-on-error */
1460 0001CD17 L381:
1461 0001CD17 # } /* end of compare error */
1462 0001CD17 # } while( index++ < max_cmpd_1_index );
1463 0001CD17 L368:
1464 0001CD17 L363:
1465 0001CD17 0d effffff0d3 50 movl _index,r0
1466 0001CD1E 6d effffff0cc incl _index
1467 0001CD24 1d 50 effffff0c5 cmpl r0,_max_cmpd_1_index
1468 0001CD2B 81 03 13 fd8b jlss L364
1469 0001CD30 L362:
1470 0001CD30 # } /* end of subtest 5 */
1471 0001CD30 40 ret#2
1472 0001CD31 .set L357,0x0
1473 0001CD31 L359:
1474 0001CD31 13 fd67 jbr L360
1475 0001CD34 .data
1476 00001398 * .text
1477 0001CD34 .align 1
1478 0001CD34 .globl _cmpd2_6
1479 0001CD34 _cmpd2_6:
1480 0001CD34 0000 .word L382
1481 0001CD36 #
1482 0001CD36 #
1483 0001CD36 #
1484 0001CD36 # /****************************************************************************
1485 0001CD36 # *
1486 0001CD36 # * SUBTEST 6 - CMPD2 test Accumulator stability test
1487 0001CD36 # *
1488 0001CD36 # ****************************************************************************/
1489 0001CD36 # cmpd2_6()
1490 0001CD36 # {
1491 0001CD36 13 029a jbr L384
1492 0001CD39 L385:
1493 0001CD39 # force_loop = FALSE;
1494 0001CD39 4d effffff0b1 clrl _force_loop
1495 0001CD3F # subtest = 6;
1496 0001CD3F 0d 06 effffff0aa movl $6,_subtest
1497 0001CD46 # index = 0;
1498 0001CD46 4d effffff0a4 clrl _index
1499 0001CD4C # do
1500 0001CD4C L388:
1501 0001CD4C # {
1502 0001CD4C # dbl_value_1 = cmpd_1_data[index].one; /* get the data operands */
1503 0001CD4C 5c 14 effffff09d 50 mull3 $20,_index,r0
1504 0001CD54 0c 8f00000000 50 addl2 $_cmpd_1_data,r0
1505 0001CD5B 0d a004 effffff091 movl 4(r0),_dbl_value_1+4
1506 0001CD63 0d 60 effffff086 movl (r0),_dbl_value_1
1507 0001CD6A # dbl_value_2 = cmpd_1_data[index].two;
1508 0001CD6A 5c 14 effffff07f 50 mull3 $20,_index,r0
1509 0001CD72 0c 8f00000008 50 addl2 $_cmpd_1_data+8,r0
1510 0001CD79 0d a004 effffff073 movl 4(r0),_dbl_value_2+4
1511 0001CD81 0d 60 effffff068 movl (r0),_dbl_value_2
1512 0001CD88 # sgl_value_1 = dbl_value_1.m;
1513 0001CD88 0d effffff062 effffff05d movl _dbl_value_1,_sgl_value_1
1514 0001CD93 # sgl_value_2 = dbl_value_1.l;
1515 0001CD93 0d effffff05b effffff052 movl _dbl_value_1+4,_sgl_value_2
1516 0001CD9E # sgl_value_3 = dbl_value_2.m;
1517 0001CD9E 0d effffff04c effffff047 movl _dbl_value_2,_sgl_value_3
1518 0001CDA9 # sgl_value_4 = dbl_value_2.l;
1519 0001CDA9 0d effffff045 effffff03c movl _dbl_value_2+4,_sgl_value_4
1520 0001CDB4 # index2 = 0; /* clear Acc. data index */
1521 0001CDB4 4d effffff036 clrl _index2
1522 0001CDBA # do
1523 0001CDBA L391:
1524 0001CDBA # {
1525 0001CDBA # dbl_ld_acc = ldd_1_data[index2].ld; /* get the Accumulator data */
1526 0001CDBA 48 04 effffff02f 50 shll $4,_index2,r0
1527 0001CDC2 0c 8f00000000 50 addl2 $_ldd_1_data,r0
1528 0001CDC9 0d a004 effffff023 movl 4(r0),_dbl_ld_acc+4
1529 0001CDD1 0d 60 effffff018 movl (r0),_dbl_ld_acc
1530 0001CDD8 # if( !(dbl_ld_acc.m & 0x7f800000 ) ) {
1531 0001CDD8 3d 8f7f800000 effffff00d bitl $2139095040,_dbl_ld_acc
1532 0001CDE3 21 0e jneq L392
1533 0001CDE5 # dbl_expected.m = 0; /* expect a '0' stored */
1534 0001CDE5 4d effffff005 clrl _dbl_expected
1535 0001CDEB # dbl_expected.l = 0;
1536 0001CDEB 4d effffff003 clrl _dbl_expected+4
1537 0001CDF1 # } else
1538 0001CDF1 11 16 jbr L393
1539 0001CDF3 L392:
1540 0001CDF3 # dbl_expected = dbl_ld_acc;
1541 0001CDF3 0d efffffeffb efffffeff6 movl _dbl_ld_acc+4,_dbl_expected+4
1542 0001CDFE 0d efffffefec efffffefe7 movl _dbl_ld_acc,_dbl_expected
1543 0001CE09 L393:
1544 0001CE09 # asm("ldd _dbl_ld_acc"); /* load the acc */
1545 0001CE09 07 efffffefe1 ldd _dbl_ld_acc
1546 0001CE0F # /*
1547 0001CE0F # * If LOOP ON ERROR is set, this is the loop for this subtest.
1548 0001CE0F # * The force loop flag is set after the first error.
1549 0001CE0F # */
1550 0001CE0F # asm("_cmpd2_6_lp1:");
1551 0001CE0F _cmpd2_6_lp1:
1552 0001CE0F # asm("nop");
1553 0001CE0F 10 nop
1554 0001CE10 # asm("cmpd2 _dbl_value_1,_dbl_value_2");/* compare the operands */
1555 0001CE10 47 efffffefda efffffefd5 cmpd2 _dbl_value_1,_dbl_value_2
1556 0001CE1B # asm("nop");
1557 0001CE1B 10 nop
1558 0001CE1C # asm("std _dbl_st_acc"); /* store the accumulator */
1559 0001CE1C 27 efffffefce std _dbl_st_acc
1560 0001CE22 # if( force_loop ) /* loop? */
1561 0001CE22 5d efffffefc8 tstl _force_loop
1562 0001CE28 31 02 jeql L394
1563 0001CE2A # asm("brb _cmpd2_6_lp1");; /* run the loop again */
1564 0001CE2A 11 e3 brb _cmpd2_6_lp1
1565 0001CE2C L394:
1566 0001CE2C # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the final */
1567 0001CE2C # (dbl_st_acc.l != dbl_expected.l) ) { /* results */
1568 0001CE2C 1d efffffefbe efffffefb9 cmpl _dbl_st_acc,_dbl_expected
1569 0001CE37 21 10 jneq L9995
1570 0001CE39 1d efffffefb5 efffffefb0 cmpl _dbl_st_acc+4,_dbl_expected+4
1571 0001CE44 21 03 13 0151 jeql L395
1572 0001CE49 L9995:
1573 0001CE49 # errcnt++; /* bump the error count */
1574 0001CE49 6d efffffefa1 incl _errcnt
1575 0001CE4F # if ( prt_error ) {
1576 0001CE4F 5d efffffef9b tstl _prt_error
1577 0001CE55 21 03 13 011a jeql L396
1578 0001CE5A # writes(" \n"); /* start a new print line */
1579 0001CE5A .data 1
1580 000016cf * L397:
1581 000016cf * 200A00 .ascii " \12\0"
1582 000016d2 * .text
1583 0001CE5A dd 8f000016cf pushl $L397
1584 0001CE60 fe 08 efffffef89 callf $8,_writes
1585 0001CE67 # writes("cycle: ");
1586 0001CE67 .data 1
1587 000016d2 * L398:
1588 000016d2 * 6379636C653A2000 .ascii "cycle: \0"
1589 000016da * .text
1590 0001CE67 dd 8f000016d2 pushl $L398
1591 0001CE6D fe 08 efffffef7c callf $8,_writes
1592 0001CE74 # writed( cycle );
1593 0001CE74 dd efffffef76 pushl _cycle
1594 0001CE7A fe 08 efffffef6f callf $8,_writed
1595 0001CE81 # writes(" CMPD2 test ");
1596 0001CE81 .data 1
1597 000016da * L399:
1598 000016da * 2020434D50443220746573742 .ascii " CMPD2 test \0"
000
1599 000016e8 * .text
1600 0001CE81 dd 8f000016da pushl $L399
1601 0001CE87 fe 08 efffffef62 callf $8,_writes
1602 0001CE8E # writed( test_no );
1603 0001CE8E dd efffffef5c pushl _test_no
1604 0001CE94 fe 08 efffffef55 callf $8,_writed
1605 0001CE9B # writes(", subtest 6 - BAD FINAL ACC\n");
1606 0001CE9B .data 1
1607 000016e8 * L400:
1608 000016e8 * 2C20737562746573742036202 .ascii ", subtest 6 - BAD FINAL ACC\12\0"
D204241442046494E414C2041
43430A00
1609 00001705 * .text
1610 0001CE9B dd 8f000016e8 pushl $L400
1611 0001CEA1 fe 08 efffffef48 callf $8,_writes
1612 0001CEA8 # print_cmpd2_data();
1613 0001CEA8 fe 04 ef00000127 callf $4,_print_cmpd2_data
1614 0001CEAF # writes(", index = ");
1615 0001CEAF .data 1
1616 00001705 * L401:
1617 00001705 * 2C202020696E646578203D200 .ascii ", index = \0"
0
1618 00001712 * .text
1619 0001CEAF dd 8f00001705 pushl $L401
1620 0001CEB5 fe 08 efffffef34 callf $8,_writes
1621 0001CEBC # writed( index );
1622 0001CEBC dd efffffef2e pushl _index
1623 0001CEC2 fe 08 efffffef27 callf $8,_writed
1624 0001CEC9 # writec('\n');
1625 0001CEC9 dd 0a pushl $10
1626 0001CECB fe 08 efffffef1e callf $8,_writec
1627 0001CED2 # writes(" final Acc = ");
1628 0001CED2 .data 1
1629 00001712 * L402:
1630 00001712 * 20202066696E616C204163632 .ascii " final Acc = \0"
03D2000
1631 00001722 * .text
1632 0001CED2 dd 8f00001712 pushl $L402
1633 0001CED8 fe 08 efffffef11 callf $8,_writes
1634 0001CEDF # write32h( dbl_st_acc.m );
1635 0001CEDF dd efffffef0b pushl _dbl_st_acc
1636 0001CEE5 fe 08 efffffef04 callf $8,_write32h
1637 0001CEEC # writec(' ');
1638 0001CEEC dd 20 pushl $32
1639 0001CEEE fe 08 efffffeefb callf $8,_writec
1640 0001CEF5 # write32h( dbl_st_acc.l );
1641 0001CEF5 dd efffffeef9 pushl _dbl_st_acc+4
1642 0001CEFB fe 08 efffffeeee callf $8,_write32h
1643 0001CF02 # writes(", operand 2 = ");
1644 0001CF02 .data 1
1645 00001722 * L403:
1646 00001722 * 2C20206F706572616E6420322 .ascii ", operand 2 = \0"
03D2000
1647 00001732 * .text
1648 0001CF02 dd 8f00001722 pushl $L403
1649 0001CF08 fe 08 efffffeee1 callf $8,_writes
1650 0001CF0F # write32h( sgl_value_3);
1651 0001CF0F dd efffffeedb pushl _sgl_value_3
1652 0001CF15 fe 08 efffffeed4 callf $8,_write32h
1653 0001CF1C # writec(' ');
1654 0001CF1C dd 20 pushl $32
1655 0001CF1E fe 08 efffffeecb callf $8,_writec
1656 0001CF25 # write32h( sgl_value_4);
1657 0001CF25 dd efffffeec5 pushl _sgl_value_4
1658 0001CF2B fe 08 efffffeebe callf $8,_write32h
1659 0001CF32 # writec('\n');
1660 0001CF32 dd 0a pushl $10
1661 0001CF34 fe 08 efffffeeb5 callf $8,_writec
1662 0001CF3B # writes("expected Acc = ");
1663 0001CF3B .data 1
1664 00001732 * L404:
1665 00001732 * 6578706563746564204163632 .ascii "expected Acc = \0"
03D2000
1666 00001742 * .text
1667 0001CF3B dd 8f00001732 pushl $L404
1668 0001CF41 fe 08 efffffeea8 callf $8,_writes
1669 0001CF48 # write32h( dbl_expected.m );
1670 0001CF48 dd efffffeea2 pushl _dbl_expected
1671 0001CF4E fe 08 efffffee9b callf $8,_write32h
1672 0001CF55 # writec(' ');
1673 0001CF55 dd 20 pushl $32
1674 0001CF57 fe 08 efffffee92 callf $8,_writec
1675 0001CF5E # write32h( dbl_expected.l );
1676 0001CF5E dd efffffee90 pushl _dbl_expected+4
1677 0001CF64 fe 08 efffffee85 callf $8,_write32h
1678 0001CF6B # writec('\n');
1679 0001CF6B dd 0a pushl $10
1680 0001CF6D fe 08 efffffee7c callf $8,_writec
1681 0001CF74 # }
1682 0001CF74 # if ( halt_flg ) /* halt on error? */
1683 0001CF74 L396:
1684 0001CF74 5d efffffee76 tstl _halt_flg
1685 0001CF7A 31 09 jeql L405
1686 0001CF7C # cmpd2_er_halt( BAD_ACC_HLT );
1687 0001CF7C dd 01 pushl $1
1688 0001CF7E fe 08 ef000000b9 callf $8,_cmpd2_er_halt
1689 0001CF85 # if ( loop_on_err )
1690 0001CF85 L405:
1691 0001CF85 5d efffffee65 tstl _loop_on_err
1692 0001CF8B 31 0d jeql L406
1693 0001CF8D # {
1694 0001CF8D # force_loop = TRUE; /* set the force loop flag */
1695 0001CF8D 0d 01 efffffee5c movl $1,_force_loop
1696 0001CF94 # asm("jmp _cmpd2_6_lp1"); /* and loop */
1697 0001CF94 71 effffffe75 jmp _cmpd2_6_lp1
1698 0001CF9A # }; /* end of loop-on-error */
1699 0001CF9A L406:
1700 0001CF9A # } /* end of compare error */
1701 0001CF9A # index2++;
1702 0001CF9A L395:
1703 0001CF9A 6d efffffee50 incl _index2
1704 0001CFA0 # } while( (index2 < 10) && (index2 < max_ldf_1_index) );
1705 0001CFA0 L390:
1706 0001CFA0 1d efffffee4a 0a cmpl _index2,$10
1707 0001CFA7 81 10 jgeq L9994
1708 0001CFA9 1d efffffee41 efffffee3c cmpl _index2,_max_ldf_1_index
1709 0001CFB4 81 03 13 fe01 jlss L391
1710 0001CFB9 L9994:
1711 0001CFB9 L389:
1712 0001CFB9 # } while( index++ < max_cmpd_1_index );
1713 0001CFB9 L387:
1714 0001CFB9 0d efffffee31 50 movl _index,r0
1715 0001CFC0 6d efffffee2a incl _index
1716 0001CFC6 1d 50 efffffee23 cmpl r0,_max_cmpd_1_index
1717 0001CFCD 81 03 13 fd7a jlss L388
1718 0001CFD2 L386:
1719 0001CFD2 # } /* end of subtest 6 */
1720 0001CFD2 40 ret#2
1721 0001CFD3 .set L382,0x0
1722 0001CFD3 L384:
1723 0001CFD3 13 fd63 jbr L385
1724 0001CFD6 .data
1725 00001398 * .text
1726 0001CFD6 .align 1
1727 0001CFD6 .globl _print_cmpd2_data
1728 0001CFD6 _print_cmpd2_data:
1729 0001CFD6 0000 .word L407
1730 0001CFD8 #
1731 0001CFD8 #
1732 0001CFD8 #
1733 0001CFD8 # /**************************************************************************
1734 0001CFD8 # *
1735 0001CFD8 # * PRINT THE DATA AND STORE RESULTS
1736 0001CFD8 # *
1737 0001CFD8 # * initial Acc = xxxxxxxx xxxxxxxx, operand 1 = xxxxxxxx xxxxxxxx
1738 0001CFD8 # **************************************************************************/
1739 0001CFD8 # print_cmpd2_data()
1740 0001CFD8 # {
1741 0001CFD8 11 61 jbr L409
1742 0001CFDA L410:
1743 0001CFDA # writes(" initial Acc = ");
1744 0001CFDA .data 1
1745 00001742 * L411:
1746 00001742 * 20696E697469616C204163632 .ascii " initial Acc = \0"
03D2000
1747 00001752 * .text
1748 0001CFDA dd 8f00001742 pushl $L411
1749 0001CFE0 fe 08 efffffee09 callf $8,_writes
1750 0001CFE7 # write32h( dbl_ld_acc.m );
1751 0001CFE7 dd efffffee03 pushl _dbl_ld_acc
1752 0001CFED fe 08 efffffedfc callf $8,_write32h
1753 0001CFF4 # writec(' ');
1754 0001CFF4 dd 20 pushl $32
1755 0001CFF6 fe 08 efffffedf3 callf $8,_writec
1756 0001CFFD # write32h( dbl_ld_acc.l );
1757 0001CFFD dd efffffedf1 pushl _dbl_ld_acc+4
1758 0001D003 fe 08 efffffede6 callf $8,_write32h
1759 0001D00A # writes(", operand 1 = ");
1760 0001D00A .data 1
1761 00001752 * L412:
1762 00001752 * 2C20206F706572616E6420312 .ascii ", operand 1 = \0"
03D2000
1763 00001762 * .text
1764 0001D00A dd 8f00001752 pushl $L412
1765 0001D010 fe 08 efffffedd9 callf $8,_writes
1766 0001D017 # write32h( sgl_value_1 );
1767 0001D017 dd efffffedd3 pushl _sgl_value_1
1768 0001D01D fe 08 efffffedcc callf $8,_write32h
1769 0001D024 # writec(' ');
1770 0001D024 dd 20 pushl $32
1771 0001D026 fe 08 efffffedc3 callf $8,_writec
1772 0001D02D # write32h( sgl_value_2 );
1773 0001D02D dd efffffedbd pushl _sgl_value_2
1774 0001D033 fe 08 efffffedb6 callf $8,_write32h
1775 0001D03A # }
1776 0001D03A 40 ret#2
1777 0001D03B .set L407,0x0
1778 0001D03B L409:
1779 0001D03B 11 9d jbr L410
1780 0001D03D .data
1781 00001398 * .text
1782 0001D03D 00 .align 1
1783 0001D03E .globl _cmpd2_er_halt
1784 0001D03E _cmpd2_er_halt:
1785 0001D03E 0000 .word L413
1786 0001D040 #
1787 0001D040 #
1788 0001D040 #
1789 0001D040 # /**************************************************************************
1790 0001D040 # *
1791 0001D040 # * HALT ON ERROR ROUTINE
1792 0001D040 # *
1793 0001D040 # **************************************************************************/
1794 0001D040 # cmpd2_er_halt( halt_code )
1795 0001D040 # int halt_code;
1796 0001D040 # {
1797 0001D040 13 0140 jbr L415
1798 0001D043 L416:
1799 0001D043 # sgl_value_1 = dbl_value_1.m;
1800 0001D043 0d efffffeda7 efffffeda2 movl _dbl_value_1,_sgl_value_1
1801 0001D04E # sgl_value_2 = dbl_value_1.l;
1802 0001D04E 0d efffffeda0 efffffed97 movl _dbl_value_1+4,_sgl_value_2
1803 0001D059 # sgl_value_3 = dbl_value_2.m;
1804 0001D059 0d efffffed91 efffffed8c movl _dbl_value_2,_sgl_value_3
1805 0001D064 # sgl_value_4 = dbl_value_2.l;
1806 0001D064 0d efffffed8a efffffed81 movl _dbl_value_2+4,_sgl_value_4
1807 0001D06F # sgl_value_5 = dbl_ld_acc.m;
1808 0001D06F 0d efffffed7b efffffed76 movl _dbl_ld_acc,_sgl_value_5
1809 0001D07A # sgl_value_6 = dbl_ld_acc.l;
1810 0001D07A 0d efffffed74 efffffed6b movl _dbl_ld_acc+4,_sgl_value_6
1811 0001D085 # sgl_value_7 = dbl_st_acc.m;
1812 0001D085 0d efffffed65 efffffed60 movl _dbl_st_acc,_sgl_value_7
1813 0001D090 # sgl_value_8 = dbl_st_acc.l;
1814 0001D090 0d efffffed5e efffffed55 movl _dbl_st_acc+4,_sgl_value_8
1815 0001D09B # sgl_dummy1 = halt_code; /* get the error type */
1816 0001D09B 0d ad04 efffffed4d movl 4(fp),_sgl_dummy1
1817 0001D0A3 # asm("movl _test_no,r0"); /* r0 = test number */
1818 0001D0A3 0d efffffed47 50 movl _test_no,r0
1819 0001D0AA # asm("movl _subtest,r1"); /* r1 = subtest number */
1820 0001D0AA 0d efffffed40 51 movl _subtest,r1
1821 0001D0B1 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1822 0001D0B1 0d efffffed39 52 movl _sgl_dummy1,r2
1823 0001D0B8 # asm("movl _cycle,r3"); /* r3 = cycle count */
1824 0001D0B8 0d efffffed32 53 movl _cycle,r3
1825 0001D0BF # asm("movl _sgl_value_5,r4"); /* r4 = MS acc loaded */
1826 0001D0BF 0d efffffed2b 54 movl _sgl_value_5,r4
1827 0001D0C6 # asm("movl _sgl_value_6,r5"); /* r5 = LS acc loaded */
1828 0001D0C6 0d efffffed24 55 movl _sgl_value_6,r5
1829 0001D0CD # asm("movl _sgl_value_1,r6"); /* r6 = MS operand 1 */
1830 0001D0CD 0d efffffed1d 56 movl _sgl_value_1,r6
1831 0001D0D4 # asm("movl _sgl_value_2,r7"); /* r7 = MS operand 1 */
1832 0001D0D4 0d efffffed16 57 movl _sgl_value_2,r7
1833 0001D0DB # asm("movl _sgl_value_3,r8"); /* r8 = MS operand 2 */
1834 0001D0DB 0d efffffed0f 58 movl _sgl_value_3,r8
1835 0001D0E2 # asm("movl _sgl_value_4,r9"); /* r9 = MS operand 2 */
1836 0001D0E2 0d efffffed08 59 movl _sgl_value_4,r9
1837 0001D0E9 # asm("movl _psl_val,r10"); /* r10 = actual PSL */
1838 0001D0E9 0d efffffed01 5a movl _psl_val,r10
1839 0001D0F0 # if( halt_code == BAD_ACC_HLT ) {
1840 0001D0F0 1d ad04 01 cmpl 4(fp),$1
1841 0001D0F4 21 34 jneq L417
1842 0001D0F6 # sgl_value_1 = dbl_expected.m;
1843 0001D0F6 0d efffffecf4 efffffecef movl _dbl_expected,_sgl_value_1
1844 0001D101 # sgl_value_2 = dbl_expected.l;
1845 0001D101 0d efffffeced efffffece4 movl _dbl_expected+4,_sgl_value_2
1846 0001D10C # asm("movl _sgl_value_7,r11"); /* r11 = MS stored */
1847 0001D10C 0d efffffecde 5b movl _sgl_value_7,r11
1848 0001D113 # asm("movl _sgl_value_8,r12"); /* r12 = LS stored */
1849 0001D113 0d efffffecd7 5c movl _sgl_value_8,r12
1850 0001D11A # asm("movl _sgl_value_1,r13"); /* r13 = MS expected */
1851 0001D11A 0d efffffecd0 5d movl _sgl_value_1,r13
1852 0001D121 # asm("movl _sgl_value_2,r14"); /* r14 = LS expected */
1853 0001D121 0d efffffecc9 5e movl _sgl_value_2,r14
1854 0001D128 # } else
1855 0001D128 11 57 jbr L418
1856 0001D12A L417:
1857 0001D12A # if( halt_code == BAD_REG_HLT ) {
1858 0001D12A 1d ad04 02 cmpl 4(fp),$2
1859 0001D12E 21 3d jneq L419
1860 0001D130 # sgl_dummy1 = load_regs[index2];
1861 0001D130 0d efffffecba 50 movl _index2,r0
1862 0001D137 0d 40efffffecb2 movl _load_regs[r0],_sgl_dummy1
efffffecad
1863 0001D143 # sgl_dummy2 = store_regs[index2];
1864 0001D143 0d efffffeca7 50 movl _index2,r0
1865 0001D14A 0d 40efffffec9f movl _store_regs[r0],_sgl_dummy2
efffffec9a
1866 0001D156 # asm("movl _index2,r11"); /* r11 = bad register # */
1867 0001D156 0d efffffec94 5b movl _index2,r11
1868 0001D15D # asm("movl _sgl_dummy2,r12"); /* r12 = actual value */
1869 0001D15D 0d efffffec8d 5c movl _sgl_dummy2,r12
1870 0001D164 # asm("movl _sgl_dummy1,r13"); /* r13 = expected value */
1871 0001D164 0d efffffec86 5d movl _sgl_dummy1,r13
1872 0001D16B # } else
1873 0001D16B 11 14 jbr L420
1874 0001D16D L419:
1875 0001D16D # if( halt_code == BAD_PSL_HLT ) {
1876 0001D16D 1d ad04 03 cmpl 4(fp),$3
1877 0001D171 21 0e jneq L421
1878 0001D173 # asm("movl _exp_psl,r11"); /* r11 = expected PSL */
1879 0001D173 0d efffffec77 5b movl _exp_psl,r11
1880 0001D17A # asm("movl _index,r12"); /* r12 = data index */
1881 0001D17A 0d efffffec70 5c movl _index,r12
1882 0001D181 # };
1883 0001D181 L421:
1884 0001D181 L420:
1885 0001D181 L418:
1886 0001D181 # asm("halt"); /* HALT ... */
1887 0001D181 00 halt
1888 0001D182 # }
1889 0001D182 40 ret#2
1890 0001D183 .set L413,0x0
1891 0001D183 L415:
1892 0001D183 13 febd jbr L416
1893 0001D186 .data
1893 00038F76 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.