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