![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to logf.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 logf.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 00000a60 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _logf
6: 6 00000000 _logf:
7: 7 000215BC 0000 .word L215
8: 8 000215BE # #include "fpp_defs.h"
9: 9 000215BE #
10: 10 000215BE #
11: 11 000215BE #
12: 12 000215BE # /***************************************************************************
13: 13 000215BE # *
14: 14 000215BE # * LOGF - SINGLE PRECISION FLOATING POINT LOGF FUNCTION TEST
15: 15 000215BE # *
16: 16 000215BE # * LOGF TEST MONITOR
17: 17 000215BE # *
18: 18 000215BE # *****************************************************************************/
19: 19 000215BE # logf()
20: 20 000215BE # {
21: 21 000215BE 11 4f jbr L217
22: 22 000215C0 L218:
23: 23 000215C0 # asm(".globl _logf_t");
24: 24 000215C0 .globl _logf_t
25: 25 000215C0 # asm("_logf_t:"); /* entry address */
26: 26 000215C0 _logf_t:
27: 27 000215C0 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
28: 28 000215C0 1d effffffff6 01 cmpl _cycle,$1
29: 29 000215C7 21 15 jneq L219
30: 30 000215C9 5d efffffffed tstl _prt_hdrs
31: 31 000215CF 31 0d jeql L219
32: 32 000215D1 # {
33: 33 000215D1 # writes(" LOGF");
34: 34 000215D1 .data 1
35: 35 00000a60 * L221:
36: 36 00000a60 * 204C4F474600 .ascii " LOGF\0"
37: 37 00000a66 * .text
38: 38 000215D1 dd 8f00000a60 pushl $L221
39: 39 000215D7 fe 08 efffffffde callf $8,_writes
40: 40 000215DE # }
41: 41 000215DE # logf_1(); /* test log function w/ delay */
42: 42 000215DE L219:
43: 43 000215DE fe 04 ef0000002d callf $4,_logf_1
44: 44 000215E5 # logf_2(); /* test log function */
45: 45 000215E5 fe 04 ef00000198 callf $4,_logf_2
46: 46 000215EC # logf_3(); /* register corruption */
47: 47 000215EC fe 04 ef000002f1 callf $4,_logf_3
48: 48 000215F3 # logf_4(); /* test the PSL */
49: 49 000215F3 fe 04 ef000004d4 callf $4,_logf_4
50: 50 000215FA # logf_5(); /* pipelined entry */
51: 51 000215FA fe 04 ef0000067d callf $4,_logf_5
52: 52 00021601 # logf_6(); /* pipelined exit */
53: 53 00021601 fe 04 ef000007d2 callf $4,_logf_6
54: 54 00021608 # asm("jmp *return"); /* return to the test monitor */
55: 55 00021608 71 ffffffffae jmp *return
56: 56 0002160E # }
57: 57 0002160E 40 ret#2
58: 58 0002160F .set L215,0x0
59: 59 0002160F L217:
60: 60 0002160F 11 af jbr L218
61: 61 00021611 .data
62: 62 00000a60 * .text
63: 63 00021611 00 .align 1
64: 64 00021612 .globl _logf_1
65: 65 00021612 _logf_1:
66: 66 00021612 0000 .word L228
67: 67 00021614 #
68: 68 00021614 # /***************************************************************************
69: 69 00021614 # *
70: 70 00021614 # * SUBTEST 1 - LOGF FUNCTION
71: 71 00021614 # *
72: 72 00021614 # ***************************************************************************/
73: 73 00021614 # logf_1()
74: 74 00021614 # {
75: 75 00021614 13 016a jbr L230
76: 76 00021617 L231:
77: 77 00021617 # #define DELAY 15 /* delay 30 ticks between LOGF & STF */
78: 78 00021617 # force_loop = FALSE; /* clear the LOOP flag */
79: 79 00021617 4d efffffff9f clrl _force_loop
80: 80 0002161D # subtest = 1;
81: 81 0002161D 0d 01 efffffff98 movl $1,_subtest
82: 82 00021624 # index = 0;
83: 83 00021624 4d efffffff92 clrl _index
84: 84 0002162A # do
85: 85 0002162A L234:
86: 86 0002162A # {
87: 87 0002162A # sgl_ld_acc = logf_1_data[index].ld; /* get the operand */
88: 88 0002162A 0d efffffff8c 50 movl _index,r0
89: 89 00021631 48 03 50 50 shll $3,r0,r0
90: 90 00021635 0d e000000000 efffffff7c movl _logf_1_data(r0),_sgl_ld_acc
91: 91 00021640 # sgl_expected = logf_1_data[index].exp; /* get expected results */
92: 92 00021640 0d efffffff76 50 movl _index,r0
93: 93 00021647 48 03 50 50 shll $3,r0,r0
94: 94 0002164B 0d e000000004 efffffff66 movl _logf_1_data+4(r0),_sgl_expected
95: 95 00021656 # sgl_dummy1 = DELAY;
96: 96 00021656 0d 0f efffffff5f movl $15,_sgl_dummy1
97: 97 0002165D # /*
98: 98 0002165D # * If LOOP ON ERROR is set, this is the loop for this subtest.
99: 99 0002165D # * The force loop flag is set after the first error.
100: 100 0002165D # */
101: 101 0002165D # asm("_logf_1_lp1:");
102: 102 0002165D _logf_1_lp1:
103: 103 0002165D # asm("movl _sgl_ld_acc,r4"); /* set the data to load */
104: 104 0002165D 0d efffffff59 54 movl _sgl_ld_acc,r4
105: 105 00021664 # asm("ldf r4"); /* load the accumulator */
106: 106 00021664 06 54 ldf r4
107: 107 00021666 # asm("movl _sgl_dummy1,r0"); /* get the delay factor */
108: 108 00021666 0d efffffff50 50 movl _sgl_dummy1,r0
109: 109 0002166D # asm("logf"); /* get ACC.'s log */
110: 110 0002166D 35 logf
111: 111 0002166E # asm("1:");
112: 112 0002166E 1:
113: 113 0002166E # asm("decl r0"); /* delay to let the LOGF */
114: 114 0002166E 7d 50 decl r0
115: 115 00021670 # asm("bgtr 1b"); /* instruction finish */
116: 116 00021670 41 fc bgtr 1b
117: 117 00021672 # asm("stf r5"); /* store the result */
118: 118 00021672 26 55 stf r5
119: 119 00021674 # if( force_loop )
120: 120 00021674 5d efffffff42 tstl _force_loop
121: 121 0002167A 31 02 jeql L235
122: 122 0002167C # asm("brb _logf_1_lp1");; /* loop on the error */
123: 123 0002167C 11 df brb _logf_1_lp1
124: 124 0002167E L235:
125: 125 0002167E # /*
126: 126 0002167E # * end error loop
127: 127 0002167E # */
128: 128 0002167E # asm("movl r5,_sgl_st_acc"); /* save the result */
129: 129 0002167E 0d 55 efffffff37 movl r5,_sgl_st_acc
130: 130 00021685 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
131: 131 00021685 1d efffffff31 efffffff2c cmpl _sgl_st_acc,_sgl_expected
132: 132 00021690 21 03 13 00d2 jeql L236
133: 133 00021695 # errcnt++; /* bump the error count */
134: 134 00021695 6d efffffff21 incl _errcnt
135: 135 0002169B # if ( prt_error ) {
136: 136 0002169B 5d efffffff1b tstl _prt_error
137: 137 000216A1 21 03 13 009b jeql L237
138: 138 000216A6 # writes(" \n"); /* start a new print line */
139: 139 000216A6 .data 1
140: 140 00000a66 * L238:
141: 141 00000a66 * 200A00 .ascii " \12\0"
142: 142 00000a69 * .text
143: 143 000216A6 dd 8f00000a66 pushl $L238
144: 144 000216AC fe 08 efffffff09 callf $8,_writes
145: 145 000216B3 # writes("cycle: ");
146: 146 000216B3 .data 1
147: 147 00000a69 * L239:
148: 148 00000a69 * 6379636C653A2000 .ascii "cycle: \0"
149: 149 00000a71 * .text
150: 150 000216B3 dd 8f00000a69 pushl $L239
151: 151 000216B9 fe 08 effffffefc callf $8,_writes
152: 152 000216C0 # writed( cycle );
153: 153 000216C0 dd effffffef6 pushl _cycle
154: 154 000216C6 fe 08 effffffeef callf $8,_writed
155: 155 000216CD # writes(" LOGF test ");
156: 156 000216CD .data 1
157: 157 00000a71 * L241:
158: 158 00000a71 * 2020204C4F474620746573742 .ascii " LOGF test \0"
159: 000
160: 159 00000a7f * .text
161: 160 000216CD dd 8f00000a71 pushl $L241
162: 161 000216D3 fe 08 effffffee2 callf $8,_writes
163: 162 000216DA # writed( test_no );
164: 163 000216DA dd effffffedc pushl _test_no
165: 164 000216E0 fe 08 effffffed5 callf $8,_writed
166: 165 000216E7 # writes(", subtest 1 (delayed store) - BAD FINAL ACC\n");
167: 166 000216E7 .data 1
168: 167 00000a7f * L242:
169: 168 00000a7f * 2C20737562746573742031202 .ascii ", subtest 1 (delayed store) - BAD FINAL ACC\12\0"
170: 864656C617965642073746F72
171: 6529202D204241442046494E4
172: 14C204143430A00
173: 169 00000aac * .text
174: 170 000216E7 dd 8f00000a7f pushl $L242
175: 171 000216ED fe 08 effffffec8 callf $8,_writes
176: 172 000216F4 # print_logf_data();
177: 173 000216F4 fe 04 ef0000083b callf $4,_print_logf_data
178: 174 000216FB # writes(", data index = ");
179: 175 000216FB .data 1
180: 176 00000aac * L244:
181: 177 00000aac * 2C20206461746120696E64657 .ascii ", data index = \0"
182: 8203D2000
183: 178 00000abd * .text
184: 179 000216FB dd 8f00000aac pushl $L244
185: 180 00021701 fe 08 effffffeb4 callf $8,_writes
186: 181 00021708 # writed( index );
187: 182 00021708 dd effffffeae pushl _index
188: 183 0002170E fe 08 effffffea7 callf $8,_writed
189: 184 00021715 # writec('\n');
190: 185 00021715 dd 0a pushl $10
191: 186 00021717 fe 08 effffffe9e callf $8,_writec
192: 187 0002171E # writes(" expected = ");
193: 188 0002171E .data 1
194: 189 00000abd * L246:
195: 190 00000abd * 2020202020202020202020202 .ascii " expected = \0"
196: 0202020202020202020202020
197: 206578706563746564203D200
198: 0
199: 191 00000ae3 * .text
200: 192 0002171E dd 8f00000abd pushl $L246
201: 193 00021724 fe 08 effffffe91 callf $8,_writes
202: 194 0002172B # write32h( sgl_expected );
203: 195 0002172B dd effffffe8b pushl _sgl_expected
204: 196 00021731 fe 08 effffffe84 callf $8,_write32h
205: 197 00021738 # writec('\n');
206: 198 00021738 dd 0a pushl $10
207: 199 0002173A fe 08 effffffe7b callf $8,_writec
208: 200 00021741 # }
209: 201 00021741 # if ( halt_flg ) /* halt on error? */
210: 202 00021741 L237:
211: 203 00021741 5d effffffe75 tstl _halt_flg
212: 204 00021747 31 09 jeql L248
213: 205 00021749 # logf_er_halt( BAD_ACC_HLT );
214: 206 00021749 dd 01 pushl $1
215: 207 0002174B fe 08 ef00000820 callf $8,_logf_er_halt
216: 208 00021752 # if ( loop_on_err )
217: 209 00021752 L248:
218: 210 00021752 5d effffffe64 tstl _loop_on_err
219: 211 00021758 31 0d jeql L250
220: 212 0002175A # {
221: 213 0002175A # force_loop = TRUE; /* set the force loop flag */
222: 214 0002175A 0d 01 effffffe5b movl $1,_force_loop
223: 215 00021761 # asm("jmp _logf_1_lp1"); /* and loop */
224: 216 00021761 71 effffffef6 jmp _logf_1_lp1
225: 217 00021767 # }
226: 218 00021767 # } /* end of compare error */
227: 219 00021767 L250:
228: 220 00021767 # } while( index++ < max_logf_1_index );
229: 221 00021767 L236:
230: 222 00021767 L233:
231: 223 00021767 0d effffffe4f 50 movl _index,r0
232: 224 0002176E 6d effffffe48 incl _index
233: 225 00021774 1d 50 effffffe41 cmpl r0,_max_logf_1_index
234: 226 0002177B 81 03 13 feaa jlss L234
235: 227 00021780 L232:
236: 228 00021780 # } /* end of subtest 1 */
237: 229 00021780 40 ret#2
238: 230 00021781 .set L228,0x0
239: 231 00021781 L230:
240: 232 00021781 13 fe93 jbr L231
241: 233 00021784 .data
242: 234 00000a60 * .text
243: 235 00021784 .align 1
244: 236 00021784 .globl _logf_2
245: 237 00021784 _logf_2:
246: 238 00021784 0000 .word L251
247: 239 00021786 #
248: 240 00021786 #
249: 241 00021786 #
250: 242 00021786 # /***************************************************************************
251: 243 00021786 # *
252: 244 00021786 # * SUBTEST 2 - LOGF FUNCTION
253: 245 00021786 # *
254: 246 00021786 # ***************************************************************************/
255: 247 00021786 # logf_2()
256: 248 00021786 # {
257: 249 00021786 13 0158 jbr L253
258: 250 00021789 L254:
259: 251 00021789 # force_loop = FALSE; /* clear the LOOP flag */
260: 252 00021789 4d effffffe2d clrl _force_loop
261: 253 0002178F # subtest = 2;
262: 254 0002178F 0d 02 effffffe26 movl $2,_subtest
263: 255 00021796 # index = 0;
264: 256 00021796 4d effffffe20 clrl _index
265: 257 0002179C # do
266: 258 0002179C L257:
267: 259 0002179C # {
268: 260 0002179C # sgl_ld_acc = logf_1_data[index].ld; /* get the operand */
269: 261 0002179C 0d effffffe1a 50 movl _index,r0
270: 262 000217A3 48 03 50 50 shll $3,r0,r0
271: 263 000217A7 0d e000000000 effffffe0a movl _logf_1_data(r0),_sgl_ld_acc
272: 264 000217B2 # sgl_expected = logf_1_data[index].exp; /* get expected results */
273: 265 000217B2 0d effffffe04 50 movl _index,r0
274: 266 000217B9 48 03 50 50 shll $3,r0,r0
275: 267 000217BD 0d e000000004 effffffdf4 movl _logf_1_data+4(r0),_sgl_expected
276: 268 000217C8 # /*
277: 269 000217C8 # * If LOOP ON ERROR is set, this is the loop for this subtest.
278: 270 000217C8 # * The force loop flag is set after the first error.
279: 271 000217C8 # */
280: 272 000217C8 # asm("_logf_2_lp1:");
281: 273 000217C8 _logf_2_lp1:
282: 274 000217C8 # asm("movl _sgl_ld_acc,r4"); /* set the data to load */
283: 275 000217C8 0d effffffdee 54 movl _sgl_ld_acc,r4
284: 276 000217CF # asm("ldf r4"); /* load the accumulator */
285: 277 000217CF 06 54 ldf r4
286: 278 000217D1 # asm("logf"); /* get ACC.'s log */
287: 279 000217D1 35 logf
288: 280 000217D2 # asm("stf r5"); /* store the result */
289: 281 000217D2 26 55 stf r5
290: 282 000217D4 # if( force_loop )
291: 283 000217D4 5d effffffde2 tstl _force_loop
292: 284 000217DA 31 02 jeql L258
293: 285 000217DC # asm("brb _logf_2_lp1");; /* loop on the error */
294: 286 000217DC 11 ea brb _logf_2_lp1
295: 287 000217DE L258:
296: 288 000217DE # /*
297: 289 000217DE # * end error loop
298: 290 000217DE # */
299: 291 000217DE # asm("movl r5,_sgl_st_acc"); /* save the result */
300: 292 000217DE 0d 55 effffffdd7 movl r5,_sgl_st_acc
301: 293 000217E5 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
302: 294 000217E5 1d effffffdd1 effffffdcc cmpl _sgl_st_acc,_sgl_expected
303: 295 000217F0 21 03 13 00d2 jeql L259
304: 296 000217F5 # errcnt++; /* bump the error count */
305: 297 000217F5 6d effffffdc1 incl _errcnt
306: 298 000217FB # if ( prt_error ) {
307: 299 000217FB 5d effffffdbb tstl _prt_error
308: 300 00021801 21 03 13 009b jeql L260
309: 301 00021806 # writes(" \n"); /* start a new print line */
310: 302 00021806 .data 1
311: 303 00000ae3 * L261:
312: 304 00000ae3 * 200A00 .ascii " \12\0"
313: 305 00000ae6 * .text
314: 306 00021806 dd 8f00000ae3 pushl $L261
315: 307 0002180C fe 08 effffffda9 callf $8,_writes
316: 308 00021813 # writes("cycle: ");
317: 309 00021813 .data 1
318: 310 00000ae6 * L262:
319: 311 00000ae6 * 6379636C653A2000 .ascii "cycle: \0"
320: 312 00000aee * .text
321: 313 00021813 dd 8f00000ae6 pushl $L262
322: 314 00021819 fe 08 effffffd9c callf $8,_writes
323: 315 00021820 # writed( cycle );
324: 316 00021820 dd effffffd96 pushl _cycle
325: 317 00021826 fe 08 effffffd8f callf $8,_writed
326: 318 0002182D # writes(" LOGF test ");
327: 319 0002182D .data 1
328: 320 00000aee * L263:
329: 321 00000aee * 2020204C4F474620746573742 .ascii " LOGF test \0"
330: 000
331: 322 00000afc * .text
332: 323 0002182D dd 8f00000aee pushl $L263
333: 324 00021833 fe 08 effffffd82 callf $8,_writes
334: 325 0002183A # writed( test_no );
335: 326 0002183A dd effffffd7c pushl _test_no
336: 327 00021840 fe 08 effffffd75 callf $8,_writed
337: 328 00021847 # writes(", subtest 2 (immediate store) - BAD FINAL ACC\n");
338: 329 00021847 .data 1
339: 330 00000afc * L264:
340: 331 00000afc * 2C20737562746573742032202 .ascii ", subtest 2 (immediate store) - BAD FINAL ACC\12\0"
341: 8696D6D656469617465207374
342: 6F726529202D2042414420464
343: 94E414C204143430A00
344: 332 00000b2b * .text
345: 333 00021847 dd 8f00000afc pushl $L264
346: 334 0002184D fe 08 effffffd68 callf $8,_writes
347: 335 00021854 # print_logf_data();
348: 336 00021854 fe 04 ef000006db callf $4,_print_logf_data
349: 337 0002185B # writes(", data index = ");
350: 338 0002185B .data 1
351: 339 00000b2b * L265:
352: 340 00000b2b * 2C20206461746120696E64657 .ascii ", data index = \0"
353: 8203D2000
354: 341 00000b3c * .text
355: 342 0002185B dd 8f00000b2b pushl $L265
356: 343 00021861 fe 08 effffffd54 callf $8,_writes
357: 344 00021868 # writed( index );
358: 345 00021868 dd effffffd4e pushl _index
359: 346 0002186E fe 08 effffffd47 callf $8,_writed
360: 347 00021875 # writec('\n');
361: 348 00021875 dd 0a pushl $10
362: 349 00021877 fe 08 effffffd3e callf $8,_writec
363: 350 0002187E # writes(" expected = ");
364: 351 0002187E .data 1
365: 352 00000b3c * L266:
366: 353 00000b3c * 2020202020202020202020202 .ascii " expected = \0"
367: 0202020202020202020202020
368: 206578706563746564203D200
369: 0
370: 354 00000b62 * .text
371: 355 0002187E dd 8f00000b3c pushl $L266
372: 356 00021884 fe 08 effffffd31 callf $8,_writes
373: 357 0002188B # write32h( sgl_expected );
374: 358 0002188B dd effffffd2b pushl _sgl_expected
375: 359 00021891 fe 08 effffffd24 callf $8,_write32h
376: 360 00021898 # writec('\n');
377: 361 00021898 dd 0a pushl $10
378: 362 0002189A fe 08 effffffd1b callf $8,_writec
379: 363 000218A1 # }
380: 364 000218A1 # if ( halt_flg ) /* halt on error? */
381: 365 000218A1 L260:
382: 366 000218A1 5d effffffd15 tstl _halt_flg
383: 367 000218A7 31 09 jeql L267
384: 368 000218A9 # logf_er_halt( BAD_ACC_HLT );
385: 369 000218A9 dd 01 pushl $1
386: 370 000218AB fe 08 ef000006c0 callf $8,_logf_er_halt
387: 371 000218B2 # if ( loop_on_err )
388: 372 000218B2 L267:
389: 373 000218B2 5d effffffd04 tstl _loop_on_err
390: 374 000218B8 31 0d jeql L268
391: 375 000218BA # {
392: 376 000218BA # force_loop = TRUE; /* set the force loop flag */
393: 377 000218BA 0d 01 effffffcfb movl $1,_force_loop
394: 378 000218C1 # asm("jmp _logf_2_lp1"); /* and loop */
395: 379 000218C1 71 efffffff01 jmp _logf_2_lp1
396: 380 000218C7 # }
397: 381 000218C7 # } /* end of compare error */
398: 382 000218C7 L268:
399: 383 000218C7 # } while( index++ < max_logf_1_index );
400: 384 000218C7 L259:
401: 385 000218C7 L256:
402: 386 000218C7 0d effffffcef 50 movl _index,r0
403: 387 000218CE 6d effffffce8 incl _index
404: 388 000218D4 1d 50 effffffce1 cmpl r0,_max_logf_1_index
405: 389 000218DB 81 03 13 febc jlss L257
406: 390 000218E0 L255:
407: 391 000218E0 # } /* end of subtest 2 */
408: 392 000218E0 40 ret#2
409: 393 000218E1 .set L251,0x0
410: 394 000218E1 L253:
411: 395 000218E1 13 fea5 jbr L254
412: 396 000218E4 .data
413: 397 00000a60 * .text
414: 398 000218E4 .align 1
415: 399 000218E4 .globl _logf_3
416: 400 000218E4 _logf_3:
417: 401 000218E4 0000 .word L269
418: 402 000218E6 #
419: 403 000218E6 #
420: 404 000218E6 #
421: 405 000218E6 # /***************************************************************************
422: 406 000218E6 # *
423: 407 000218E6 # * SUBTEST 3 - REGISTER INTEGRITY WITH THE LOGF FUNCTION
424: 408 000218E6 # *
425: 409 000218E6 # ***************************************************************************/
426: 410 000218E6 # logf_3()
427: 411 000218E6 # {
428: 412 000218E6 13 01e1 jbr L271
429: 413 000218E9 L272:
430: 414 000218E9 # fill_reg_buf( load_regs ); /* set reg values to load */
431: 415 000218E9 dd 8f00000000 pushl $_load_regs
432: 416 000218EF fe 08 effffffcc6 callf $8,_fill_reg_buf
433: 417 000218F6 # force_loop = FALSE; /* clear the LOOP flag */
434: 418 000218F6 4d effffffcc0 clrl _force_loop
435: 419 000218FC # subtest = 3;
436: 420 000218FC 0d 03 effffffcb9 movl $3,_subtest
437: 421 00021903 # index = 0;
438: 422 00021903 4d effffffcb3 clrl _index
439: 423 00021909 # do
440: 424 00021909 L276:
441: 425 00021909 # {
442: 426 00021909 # sgl_ld_acc = logf_1_data[index].ld; /* get the operand */
443: 427 00021909 0d effffffcad 50 movl _index,r0
444: 428 00021910 48 03 50 50 shll $3,r0,r0
445: 429 00021914 0d e000000000 effffffc9d movl _logf_1_data(r0),_sgl_ld_acc
446: 430 0002191F # sgl_expected = logf_1_data[index].exp; /* get expected results */
447: 431 0002191F 0d effffffc97 50 movl _index,r0
448: 432 00021926 48 03 50 50 shll $3,r0,r0
449: 433 0002192A 0d e000000004 effffffc87 movl _logf_1_data+4(r0),_sgl_expected
450: 434 00021935 # /*
451: 435 00021935 # * If LOOP ON ERROR is set, this is the loop for this subtest.
452: 436 00021935 # * The force loop flag is set after the first error.
453: 437 00021935 # */
454: 438 00021935 # asm("_logf_3_lp1:");
455: 439 00021935 _logf_3_lp1:
456: 440 00021935 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
457: 441 00021935 ab 891fff effffffc7e loadr $0x1fff,_load_regs
458: 442 0002193E # asm("ldf _sgl_ld_acc"); /* load the accumulator */
459: 443 0002193E 06 effffffc78 ldf _sgl_ld_acc
460: 444 00021944 # asm("logf"); /* get ACC.'s log */
461: 445 00021944 35 logf
462: 446 00021945 # asm("stf _sgl_st_acc"); /* store the result */
463: 447 00021945 26 effffffc71 stf _sgl_st_acc
464: 448 0002194B # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
465: 449 0002194B bb 891fff effffffc68 storer $0x1fff,_store_regs
466: 450 00021954 # if( force_loop )
467: 451 00021954 5d effffffc62 tstl _force_loop
468: 452 0002195A 31 02 jeql L277
469: 453 0002195C # asm("brb _logf_3_lp1");; /* loop on the error */
470: 454 0002195C 11 d7 brb _logf_3_lp1
471: 455 0002195E L277:
472: 456 0002195E # /*
473: 457 0002195E # * end error loop
474: 458 0002195E # */
475: 459 0002195E # reg_no = 0;
476: 460 0002195E 4d effffffc58 clrl _reg_no
477: 461 00021964 # regs_ok = TRUE;
478: 462 00021964 0d 01 effffffc51 movl $1,_regs_ok
479: 463 0002196B # while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */
480: 464 0002196B L278:
481: 465 0002196B 1d effffffc4b 0d cmpl _reg_no,$13
482: 466 00021972 81 35 jgeq L279
483: 467 00021974 5d effffffc42 tstl _regs_ok
484: 468 0002197A 31 2d jeql L279
485: 469 0002197C # if( store_regs[ reg_no ] == load_regs[ reg_no ] )
486: 470 0002197C 0d effffffc3a 50 movl _reg_no,r0
487: 471 00021983 0d effffffc33 51 movl _reg_no,r1
488: 472 0002198A 1d 40effffffc2b cmpl _store_regs[r0],_load_regs[r1]
489: 41effffffc25
490: 473 00021997 21 08 jneq L280
491: 474 00021999 # reg_no++;
492: 475 00021999 6d effffffc1d incl _reg_no
493: 476 0002199F # else
494: 477 0002199F 11 06 jbr L281
495: 478 000219A1 L280:
496: 479 000219A1 # regs_ok = FALSE;
497: 480 000219A1 4d effffffc15 clrl _regs_ok
498: 481 000219A7 L281:
499: 482 000219A7 11 c2 jbr L278
500: 483 000219A9 L279:
501: 484 000219A9 # if( !regs_ok ) {
502: 485 000219A9 5d effffffc0d tstl _regs_ok
503: 486 000219AF 31 03 13 00fc jneq L282
504: 487 000219B4 # errcnt++; /* bump the error count */
505: 488 000219B4 6d effffffc02 incl _errcnt
506: 489 000219BA # if ( prt_error ) {
507: 490 000219BA 5d effffffbfc tstl _prt_error
508: 491 000219C0 21 03 13 00eb jeql L283
509: 492 000219C5 # writes(" \n"); /* start a new print line */
510: 493 000219C5 .data 1
511: 494 00000b62 * L284:
512: 495 00000b62 * 200A00 .ascii " \12\0"
513: 496 00000b65 * .text
514: 497 000219C5 dd 8f00000b62 pushl $L284
515: 498 000219CB fe 08 effffffbea callf $8,_writes
516: 499 000219D2 # writes("cycle: ");
517: 500 000219D2 .data 1
518: 501 00000b65 * L285:
519: 502 00000b65 * 6379636C653A2000 .ascii "cycle: \0"
520: 503 00000b6d * .text
521: 504 000219D2 dd 8f00000b65 pushl $L285
522: 505 000219D8 fe 08 effffffbdd callf $8,_writes
523: 506 000219DF # writed( cycle );
524: 507 000219DF dd effffffbd7 pushl _cycle
525: 508 000219E5 fe 08 effffffbd0 callf $8,_writed
526: 509 000219EC # writes(" LOGF test ");
527: 510 000219EC .data 1
528: 511 00000b6d * L286:
529: 512 00000b6d * 2020204C4F474620746573742 .ascii " LOGF test \0"
530: 000
531: 513 00000b7b * .text
532: 514 000219EC dd 8f00000b6d pushl $L286
533: 515 000219F2 fe 08 effffffbc3 callf $8,_writes
534: 516 000219F9 # writed( test_no );
535: 517 000219F9 dd effffffbbd pushl _test_no
536: 518 000219FF fe 08 effffffbb6 callf $8,_writed
537: 519 00021A06 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); {
538: 520 00021A06 .data 1
539: 521 00000b7b * L287:
540: 522 00000b7b * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0"
541: D204120524547495354455220
542: 574153204D4F4449464945440
543: A00
544: 523 00000ba2 * .text
545: 524 00021A06 dd 8f00000b7b pushl $L287
546: 525 00021A0C fe 08 effffffba9 callf $8,_writes
547: 526 00021A13 # print_logf_data();
548: 527 00021A13 fe 04 ef0000051c callf $4,_print_logf_data
549: 528 00021A1A # writec('\n');
550: 529 00021A1A dd 0a pushl $10
551: 530 00021A1C fe 08 effffffb99 callf $8,_writec
552: 531 00021A23 # writes("register ");
553: 532 00021A23 .data 1
554: 533 00000ba2 * L288:
555: 534 00000ba2 * 72656769737465722000 .ascii "register \0"
556: 535 00000bac * .text
557: 536 00021A23 dd 8f00000ba2 pushl $L288
558: 537 00021A29 fe 08 effffffb8c callf $8,_writes
559: 538 00021A30 # writed( reg_no );
560: 539 00021A30 dd effffffb86 pushl _reg_no
561: 540 00021A36 fe 08 effffffb7f callf $8,_writed
562: 541 00021A3D # writes(" = ");
563: 542 00021A3D .data 1
564: 543 00000bac * L289:
565: 544 00000bac * 203D2000 .ascii " = \0"
566: 545 00000bb0 * .text
567: 546 00021A3D dd 8f00000bac pushl $L289
568: 547 00021A43 fe 08 effffffb72 callf $8,_writes
569: 548 00021A4A # write32h( load_regs[reg_no] );
570: 549 00021A4A 0d effffffb6c 50 movl _reg_no,r0
571: 550 00021A51 dd 40effffffb64 pushl _load_regs[r0]
572: 551 00021A58 fe 08 effffffb5d callf $8,_write32h
573: 552 00021A5F # writes(", should be = ");
574: 553 00021A5F .data 1
575: 554 00000bb0 * L290:
576: 555 00000bb0 * 2C202073686F756C642062652 .ascii ", should be = \0"
577: 03D2000
578: 556 00000bc0 * .text
579: 557 00021A5F dd 8f00000bb0 pushl $L290
580: 558 00021A65 fe 08 effffffb50 callf $8,_writes
581: 559 00021A6C # write32h( store_regs[reg_no] );
582: 560 00021A6C 0d effffffb4a 50 movl _reg_no,r0
583: 561 00021A73 dd 40effffffb42 pushl _store_regs[r0]
584: 562 00021A7A fe 08 effffffb3b callf $8,_write32h
585: 563 00021A81 # writec('\n');
586: 564 00021A81 dd 0a pushl $10
587: 565 00021A83 fe 08 effffffb32 callf $8,_writec
588: 566 00021A8A # }
589: 567 00021A8A # if ( halt_flg ) /* halt on error? */
590: 568 00021A8A 5d effffffb2c tstl _halt_flg
591: 569 00021A90 31 09 jeql L291
592: 570 00021A92 # logf_er_halt( BAD_REG_HLT );
593: 571 00021A92 dd 02 pushl $2
594: 572 00021A94 fe 08 ef000004d7 callf $8,_logf_er_halt
595: 573 00021A9B # if ( loop_on_err )
596: 574 00021A9B L291:
597: 575 00021A9B 5d effffffb1b tstl _loop_on_err
598: 576 00021AA1 31 0d jeql L292
599: 577 00021AA3 # {
600: 578 00021AA3 # force_loop = TRUE; /* get the force loop flag */
601: 579 00021AA3 0d 01 effffffb12 movl $1,_force_loop
602: 580 00021AAA # asm("jmp _logf_3_lp1"); /* and loop */
603: 581 00021AAA 71 effffffe85 jmp _logf_3_lp1
604: 582 00021AB0 # }
605: 583 00021AB0 # } /* end of compare error */
606: 584 00021AB0 L292:
607: 585 00021AB0 # } /* end of while loop */
608: 586 00021AB0 L283:
609: 587 00021AB0 # } while( index++ < max_logf_1_index );
610: 588 00021AB0 L282:
611: 589 00021AB0 L275:
612: 590 00021AB0 0d effffffb06 50 movl _index,r0
613: 591 00021AB7 6d effffffaff incl _index
614: 592 00021ABD 1d 50 effffffaf8 cmpl r0,_max_logf_1_index
615: 593 00021AC4 81 03 13 fe40 jlss L276
616: 594 00021AC9 L274:
617: 595 00021AC9 # } /* end of subtest 3 */
618: 596 00021AC9 40 ret#2
619: 597 00021ACA .set L269,0x0
620: 598 00021ACA L271:
621: 599 00021ACA 13 fe1c jbr L272
622: 600 00021ACD .data
623: 601 00000a60 * .text
624: 602 00021ACD 00 .align 1
625: 603 00021ACE .globl _logf_4
626: 604 00021ACE _logf_4:
627: 605 00021ACE 0000 .word L293
628: 606 00021AD0 #
629: 607 00021AD0 #
630: 608 00021AD0 #
631: 609 00021AD0 # /************************************************************************
632: 610 00021AD0 # *
633: 611 00021AD0 # * SUBTEST 4 - Check for PSL corruption
634: 612 00021AD0 # *
635: 613 00021AD0 # ************************************************************************/
636: 614 00021AD0 # logf_4()
637: 615 00021AD0 # {
638: 616 00021AD0 13 01a8 jbr L295
639: 617 00021AD3 L296:
640: 618 00021AD3 # force_loop = FALSE; /* clear force_loop flg */
641: 619 00021AD3 4d effffffae3 clrl _force_loop
642: 620 00021AD9 # subtest = 4;
643: 621 00021AD9 0d 04 effffffadc movl $4,_subtest
644: 622 00021AE0 # fill_reg_buf( load_regs ); /* get patterns for regs */
645: 623 00021AE0 dd 8f00000000 pushl $_load_regs
646: 624 00021AE6 fe 08 effffffacf callf $8,_fill_reg_buf
647: 625 00021AED # for( index = 0; index < 3; index++ ) {
648: 626 00021AED 4d effffffac9 clrl _index
649: 627 00021AF3 L299:
650: 628 00021AF3 1d effffffac3 03 cmpl _index,$3
651: 629 00021AFA 91 03 13 017b jgeq L298
652: 630 00021AFF # sgl_ld_acc = logf_1_data[index].ld; /* get operand 1 */
653: 631 00021AFF 0d effffffab7 50 movl _index,r0
654: 632 00021B06 48 03 50 50 shll $3,r0,r0
655: 633 00021B0A 0d e000000000 effffffaa7 movl _logf_1_data(r0),_sgl_ld_acc
656: 634 00021B15 # sgl_expected = logf_1_data[index].exp; /* get expected */
657: 635 00021B15 0d effffffaa1 50 movl _index,r0
658: 636 00021B1C 48 03 50 50 shll $3,r0,r0
659: 637 00021B20 0d e000000004 effffffa91 movl _logf_1_data+4(r0),_sgl_expected
660: 638 00021B2B # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
661: 639 00021B2B 0d effffffa8b 50 movl _status_index,r0
662: 640 00021B32 0d 40effffffa83 movl _status_array[r0],_sgl_dummy1
663: effffffa7e
664: 641 00021B3E # /*
665: 642 00021B3E # * If LOOP ON ERROR is set, this is the loop for this subtest.
666: 643 00021B3E # * The force loop flag is set after the first error.
667: 644 00021B3E # */
668: 645 00021B3E # asm("_logf_4_lp1:");
669: 646 00021B3E _logf_4_lp1:
670: 647 00021B3E # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
671: 648 00021B3E 06 effffffa78 ldf _sgl_ld_acc
672: 649 00021B44 # asm("nop");
673: 650 00021B44 10 nop
674: 651 00021B45 # asm("tstl _sgl_dummy1"); /* set the PSL status */
675: 652 00021B45 5d effffffa71 tstl _sgl_dummy1
676: 653 00021B4B # asm("movpsl _init_psl"); /* save the initial PSL */
677: 654 00021B4B cd effffffa6b movpsl _init_psl
678: 655 00021B51 # asm("logf"); /* do the log */
679: 656 00021B51 35 logf
680: 657 00021B52 # asm("nop");
681: 658 00021B52 10 nop
682: 659 00021B53 # asm("movpsl _psl_val"); /* save the final PSL */
683: 660 00021B53 cd effffffa63 movpsl _psl_val
684: 661 00021B59 # asm("stf _sgl_st_acc"); /* save the accumulator */
685: 662 00021B59 26 effffffa5d stf _sgl_st_acc
686: 663 00021B5F # if( force_loop )
687: 664 00021B5F 5d effffffa57 tstl _force_loop
688: 665 00021B65 31 02 jeql L300
689: 666 00021B67 # asm("brb _logf_4_lp1");; /* loop on the error */
690: 667 00021B67 11 d5 brb _logf_4_lp1
691: 668 00021B69 L300:
692: 669 00021B69 # /*
693: 670 00021B69 # * Now compare the final PSL to the initial PSL -they should be the same
694: 671 00021B69 # */
695: 672 00021B69 # exp_psl = init_psl;
696: 673 00021B69 0d effffffa4d effffffa48 movl _init_psl,_exp_psl
697: 674 00021B74 # if( psl_val != exp_psl ) {
698: 675 00021B74 1d effffffa42 effffffa3d cmpl _psl_val,_exp_psl
699: 676 00021B7F 21 03 13 00ed jeql L301
700: 677 00021B84 # errcnt++; /* bump the error count */
701: 678 00021B84 6d effffffa32 incl _errcnt
702: 679 00021B8A # if( prt_error ) {
703: 680 00021B8A 5d effffffa2c tstl _prt_error
704: 681 00021B90 21 03 13 00b9 jeql L302
705: 682 00021B95 # writes(" \n"); /* start a new print line */
706: 683 00021B95 .data 1
707: 684 00000bc0 * L303:
708: 685 00000bc0 * 200A00 .ascii " \12\0"
709: 686 00000bc3 * .text
710: 687 00021B95 dd 8f00000bc0 pushl $L303
711: 688 00021B9B fe 08 effffffa1a callf $8,_writes
712: 689 00021BA2 # writes("cycle: ");
713: 690 00021BA2 .data 1
714: 691 00000bc3 * L304:
715: 692 00000bc3 * 6379636C653A2000 .ascii "cycle: \0"
716: 693 00000bcb * .text
717: 694 00021BA2 dd 8f00000bc3 pushl $L304
718: 695 00021BA8 fe 08 effffffa0d callf $8,_writes
719: 696 00021BAF # writed( cycle );
720: 697 00021BAF dd effffffa07 pushl _cycle
721: 698 00021BB5 fe 08 effffffa00 callf $8,_writed
722: 699 00021BBC # writes(" LOGF test ");
723: 700 00021BBC .data 1
724: 701 00000bcb * L305:
725: 702 00000bcb * 2020204C4F474620746573742 .ascii " LOGF test \0"
726: 000
727: 703 00000bd9 * .text
728: 704 00021BBC dd 8f00000bcb pushl $L305
729: 705 00021BC2 fe 08 effffff9f3 callf $8,_writes
730: 706 00021BC9 # writed( test_no );
731: 707 00021BC9 dd effffff9ed pushl _test_no
732: 708 00021BCF fe 08 effffff9e6 callf $8,_writed
733: 709 00021BD6 # writes(", subtest 4 - INCORRECT FINAL PSL\n");
734: 710 00021BD6 .data 1
735: 711 00000bd9 * L306:
736: 712 00000bd9 * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0"
737: D20494E434F52524543542046
738: 494E414C2050534C0A00
739: 713 00000bfc * .text
740: 714 00021BD6 dd 8f00000bd9 pushl $L306
741: 715 00021BDC fe 08 effffff9d9 callf $8,_writes
742: 716 00021BE3 # print_logf_data(); /* print the operands */
743: 717 00021BE3 fe 04 ef0000034c callf $4,_print_logf_data
744: 718 00021BEA # writec('\n');
745: 719 00021BEA dd 0a pushl $10
746: 720 00021BEC fe 08 effffff9c9 callf $8,_writec
747: 721 00021BF3 # writes("initial PSL = ");
748: 722 00021BF3 .data 1
749: 723 00000bfc * L307:
750: 724 00000bfc * 696E697469616C2050534C203 .ascii "initial PSL = \0"
751: D2000
752: 725 00000c0b * .text
753: 726 00021BF3 dd 8f00000bfc pushl $L307
754: 727 00021BF9 fe 08 effffff9bc callf $8,_writes
755: 728 00021C00 # write32h( init_psl );
756: 729 00021C00 dd effffff9b6 pushl _init_psl
757: 730 00021C06 fe 08 effffff9af callf $8,_write32h
758: 731 00021C0D # writes(", final PSL = ");
759: 732 00021C0D .data 1
760: 733 00000c0b * L308:
761: 734 00000c0b * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
762: 03D2000
763: 735 00000c1b * .text
764: 736 00021C0D dd 8f00000c0b pushl $L308
765: 737 00021C13 fe 08 effffff9a2 callf $8,_writes
766: 738 00021C1A # write32h( psl_val );
767: 739 00021C1A dd effffff99c pushl _psl_val
768: 740 00021C20 fe 08 effffff995 callf $8,_write32h
769: 741 00021C27 # writes(", expected PSL = ");
770: 742 00021C27 .data 1
771: 743 00000c1b * L309:
772: 744 00000c1b * 2C20206578706563746564205 .ascii ", expected PSL = \0"
773: 0534C203D2000
774: 745 00000c2e * .text
775: 746 00021C27 dd 8f00000c1b pushl $L309
776: 747 00021C2D fe 08 effffff988 callf $8,_writes
777: 748 00021C34 # write32h( exp_psl );
778: 749 00021C34 dd effffff982 pushl _exp_psl
779: 750 00021C3A fe 08 effffff97b callf $8,_write32h
780: 751 00021C41 # writes("\n");
781: 752 00021C41 .data 1
782: 753 00000c2e * L310:
783: 754 00000c2e * 0A00 .ascii "\12\0"
784: 755 00000c30 * .text
785: 756 00021C41 dd 8f00000c2e pushl $L310
786: 757 00021C47 fe 08 effffff96e callf $8,_writes
787: 758 00021C4E # }
788: 759 00021C4E # if( halt_flg )
789: 760 00021C4E L302:
790: 761 00021C4E 5d effffff968 tstl _halt_flg
791: 762 00021C54 31 09 jeql L311
792: 763 00021C56 # logf_er_halt( BAD_PSL_HLT ); /* halt on the error */
793: 764 00021C56 dd 03 pushl $3
794: 765 00021C58 fe 08 ef00000313 callf $8,_logf_er_halt
795: 766 00021C5F # if( loop_on_err ) {
796: 767 00021C5F L311:
797: 768 00021C5F 5d effffff957 tstl _loop_on_err
798: 769 00021C65 31 0a jeql L312
799: 770 00021C67 # force_loop = TRUE; /* set the force loop flag */
800: 771 00021C67 0d 01 effffff94e movl $1,_force_loop
801: 772 00021C6E # asm("brw _logf_4_lp1");; /* and loop on the error */
802: 773 00021C6E 13 fecd brw _logf_4_lp1
803: 774 00021C71 # } /* end of loop on error */
804: 775 00021C71 # } /* end of PSL corruption error */
805: 776 00021C71 L312:
806: 777 00021C71 # } /* end of WHILE loop */
807: 778 00021C71 L301:
808: 779 00021C71 L297:
809: 780 00021C71 6d effffff945 incl _index
810: 781 00021C77 13 fe79 jbr L299
811: 782 00021C7A L298:
812: 783 00021C7A # } /* end of subtest 4 */
813: 784 00021C7A 40 ret#2
814: 785 00021C7B .set L293,0x0
815: 786 00021C7B L295:
816: 787 00021C7B 13 fe55 jbr L296
817: 788 00021C7E .data
818: 789 00000a60 * .text
819: 790 00021C7E .align 1
820: 791 00021C7E .globl _logf_5
821: 792 00021C7E _logf_5:
822: 793 00021C7E 0000 .word L313
823: 794 00021C80 #
824: 795 00021C80 #
825: 796 00021C80 #
826: 797 00021C80 # /************************************************************************
827: 798 00021C80 # *
828: 799 00021C80 # * SUBTEST 5 - pipelined entry test
829: 800 00021C80 # *
830: 801 00021C80 # ************************************************************************/
831: 802 00021C80 # logf_5()
832: 803 00021C80 # {
833: 804 00021C80 13 0154 jbr L315
834: 805 00021C83 L316:
835: 806 00021C83 # force_loop = FALSE;
836: 807 00021C83 4d effffff933 clrl _force_loop
837: 808 00021C89 # subtest = 8;
838: 809 00021C89 0d 08 effffff92c movl $8,_subtest
839: 810 00021C90 # for( index = 0; index < max_logf_1_index; index++ ) {
840: 811 00021C90 4d effffff926 clrl _index
841: 812 00021C96 L319:
842: 813 00021C96 1d effffff920 effffff91b cmpl _index,_max_logf_1_index
843: 814 00021CA1 91 03 13 0130 jgeq L318
844: 815 00021CA6 # sgl_ld_acc = logf_1_data[index].ld; /* get operand 1 */
845: 816 00021CA6 0d effffff910 50 movl _index,r0
846: 817 00021CAD 48 03 50 50 shll $3,r0,r0
847: 818 00021CB1 0d e000000000 effffff900 movl _logf_1_data(r0),_sgl_ld_acc
848: 819 00021CBC # sgl_expected = logf_1_data[index].exp; /* get expected result */
849: 820 00021CBC 0d effffff8fa 50 movl _index,r0
850: 821 00021CC3 48 03 50 50 shll $3,r0,r0
851: 822 00021CC7 0d e000000004 effffff8ea movl _logf_1_data+4(r0),_sgl_expected
852: 823 00021CD2 # /*
853: 824 00021CD2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
854: 825 00021CD2 # * The force loop flag is set after the first error.
855: 826 00021CD2 # */
856: 827 00021CD2 # asm("_logf_5_lp1:");
857: 828 00021CD2 _logf_5_lp1:
858: 829 00021CD2 # asm("movl $0,r0"); /* clear r0 */
859: 830 00021CD2 0d 00 50 movl $0,r0
860: 831 00021CD5 # asm("ldf r0"); /* load the Acc. with 0.0 */
861: 832 00021CD5 06 50 ldf r0
862: 833 00021CD7 # asm("addf _sgl_ld_acc"); /* add the 1st operand */
863: 834 00021CD7 c6 effffff8df addf _sgl_ld_acc
864: 835 00021CDD # asm("logf"); /* get the log */
865: 836 00021CDD 35 logf
866: 837 00021CDE # asm("stf _sgl_st_acc"); /* store the result */
867: 838 00021CDE 26 effffff8d8 stf _sgl_st_acc
868: 839 00021CE4 # if( force_loop )
869: 840 00021CE4 5d effffff8d2 tstl _force_loop
870: 841 00021CEA 31 02 jeql L320
871: 842 00021CEC # asm("brb _logf_5_lp1");; /* loop on the error */
872: 843 00021CEC 11 e4 brb _logf_5_lp1
873: 844 00021CEE L320:
874: 845 00021CEE # /*
875: 846 00021CEE # * end error loop - test the results
876: 847 00021CEE # */
877: 848 00021CEE # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
878: 849 00021CEE 1d effffff8c8 effffff8c3 cmpl _sgl_st_acc,_sgl_expected
879: 850 00021CF9 21 03 13 00cf jeql L321
880: 851 00021CFE # errcnt++; /* bump the error count */
881: 852 00021CFE 6d effffff8b8 incl _errcnt
882: 853 00021D04 # if( prt_error ) {
883: 854 00021D04 5d effffff8b2 tstl _prt_error
884: 855 00021D0A 21 03 13 009b jeql L322
885: 856 00021D0F # writes(" \n"); /* start a new print line */
886: 857 00021D0F .data 1
887: 858 00000c30 * L323:
888: 859 00000c30 * 200A00 .ascii " \12\0"
889: 860 00000c33 * .text
890: 861 00021D0F dd 8f00000c30 pushl $L323
891: 862 00021D15 fe 08 effffff8a0 callf $8,_writes
892: 863 00021D1C # writes("cycle: ");
893: 864 00021D1C .data 1
894: 865 00000c33 * L324:
895: 866 00000c33 * 6379636C653A2000 .ascii "cycle: \0"
896: 867 00000c3b * .text
897: 868 00021D1C dd 8f00000c33 pushl $L324
898: 869 00021D22 fe 08 effffff893 callf $8,_writes
899: 870 00021D29 # writed( cycle );
900: 871 00021D29 dd effffff88d pushl _cycle
901: 872 00021D2F fe 08 effffff886 callf $8,_writed
902: 873 00021D36 # writes(" LOGF test ");
903: 874 00021D36 .data 1
904: 875 00000c3b * L325:
905: 876 00000c3b * 2020204C4F474620746573742 .ascii " LOGF test \0"
906: 000
907: 877 00000c49 * .text
908: 878 00021D36 dd 8f00000c3b pushl $L325
909: 879 00021D3C fe 08 effffff879 callf $8,_writes
910: 880 00021D43 # writed( test_no );
911: 881 00021D43 dd effffff873 pushl _test_no
912: 882 00021D49 fe 08 effffff86c callf $8,_writed
913: 883 00021D50 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n");
914: 884 00021D50 .data 1
915: 885 00000c49 * L326:
916: 886 00000c49 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0"
917: 8506970656420456E74727929
918: 202D204241442046494E414C2
919: 04143430A00
920: 887 00000c74 * .text
921: 888 00021D50 dd 8f00000c49 pushl $L326
922: 889 00021D56 fe 08 effffff85f callf $8,_writes
923: 890 00021D5D # print_logf_data();
924: 891 00021D5D fe 04 ef000001d2 callf $4,_print_logf_data
925: 892 00021D64 # writes(", data index = ");
926: 893 00021D64 .data 1
927: 894 00000c74 * L327:
928: 895 00000c74 * 2C20206461746120696E64657 .ascii ", data index = \0"
929: 8203D2000
930: 896 00000c85 * .text
931: 897 00021D64 dd 8f00000c74 pushl $L327
932: 898 00021D6A fe 08 effffff84b callf $8,_writes
933: 899 00021D71 # writed( index );
934: 900 00021D71 dd effffff845 pushl _index
935: 901 00021D77 fe 08 effffff83e callf $8,_writed
936: 902 00021D7E # writec('\n');
937: 903 00021D7E dd 0a pushl $10
938: 904 00021D80 fe 08 effffff835 callf $8,_writec
939: 905 00021D87 # writes(" expected = ");
940: 906 00021D87 .data 1
941: 907 00000c85 * L328:
942: 908 00000c85 * 2020202020202020202020202 .ascii " expected = \0"
943: 0202020202020202020202020
944: 206578706563746564203D200
945: 0
946: 909 00000cab * .text
947: 910 00021D87 dd 8f00000c85 pushl $L328
948: 911 00021D8D fe 08 effffff828 callf $8,_writes
949: 912 00021D94 # write32h( sgl_expected );
950: 913 00021D94 dd effffff822 pushl _sgl_expected
951: 914 00021D9A fe 08 effffff81b callf $8,_write32h
952: 915 00021DA1 # writec('\n');
953: 916 00021DA1 dd 0a pushl $10
954: 917 00021DA3 fe 08 effffff812 callf $8,_writec
955: 918 00021DAA # }
956: 919 00021DAA # if( halt_flg )
957: 920 00021DAA L322:
958: 921 00021DAA 5d effffff80c tstl _halt_flg
959: 922 00021DB0 31 09 jeql L329
960: 923 00021DB2 # logf_er_halt( BAD_ACC_HLT ); /* halt on the error */
961: 924 00021DB2 dd 01 pushl $1
962: 925 00021DB4 fe 08 ef000001b7 callf $8,_logf_er_halt
963: 926 00021DBB # if( loop_on_err ) {
964: 927 00021DBB L329:
965: 928 00021DBB 5d effffff7fb tstl _loop_on_err
966: 929 00021DC1 31 0a jeql L330
967: 930 00021DC3 # force_loop = TRUE; /* set the force loop flag */
968: 931 00021DC3 0d 01 effffff7f2 movl $1,_force_loop
969: 932 00021DCA # asm("brw _logf_5_lp1");; /* and loop on the error */
970: 933 00021DCA 13 ff05 brw _logf_5_lp1
971: 934 00021DCD # } /* end of loop on error */
972: 935 00021DCD # } /* end of compare error */
973: 936 00021DCD L330:
974: 937 00021DCD # } /* end of WHILE loop */
975: 938 00021DCD L321:
976: 939 00021DCD L317:
977: 940 00021DCD 6d effffff7e9 incl _index
978: 941 00021DD3 13 fec0 jbr L319
979: 942 00021DD6 L318:
980: 943 00021DD6 # } /* end of subtest 5 */
981: 944 00021DD6 40 ret#2
982: 945 00021DD7 .set L313,0x0
983: 946 00021DD7 L315:
984: 947 00021DD7 13 fea9 jbr L316
985: 948 00021DDA .data
986: 949 00000a60 * .text
987: 950 00021DDA .align 1
988: 951 00021DDA .globl _logf_6
989: 952 00021DDA _logf_6:
990: 953 00021DDA 0000 .word L331
991: 954 00021DDC #
992: 955 00021DDC #
993: 956 00021DDC #
994: 957 00021DDC # /************************************************************************
995: 958 00021DDC # *
996: 959 00021DDC # * SUBTEST 6 - pipelined exit test
997: 960 00021DDC # *
998: 961 00021DDC # ************************************************************************/
999: 962 00021DDC # logf_6()
1000: 963 00021DDC # {
1001: 964 00021DDC 13 0154 jbr L333
1002: 965 00021DDF L334:
1003: 966 00021DDF # force_loop = FALSE;
1004: 967 00021DDF 4d effffff7d7 clrl _force_loop
1005: 968 00021DE5 # subtest = 8;
1006: 969 00021DE5 0d 08 effffff7d0 movl $8,_subtest
1007: 970 00021DEC # for( index = 0; index < max_logf_1_index; index++ ) {
1008: 971 00021DEC 4d effffff7ca clrl _index
1009: 972 00021DF2 L337:
1010: 973 00021DF2 1d effffff7c4 effffff7bf cmpl _index,_max_logf_1_index
1011: 974 00021DFD 91 03 13 0130 jgeq L336
1012: 975 00021E02 # sgl_ld_acc = logf_1_data[index].ld; /* get operand 1 */
1013: 976 00021E02 0d effffff7b4 50 movl _index,r0
1014: 977 00021E09 48 03 50 50 shll $3,r0,r0
1015: 978 00021E0D 0d e000000000 effffff7a4 movl _logf_1_data(r0),_sgl_ld_acc
1016: 979 00021E18 # sgl_expected = logf_1_data[index].exp; /* get expected result */
1017: 980 00021E18 0d effffff79e 50 movl _index,r0
1018: 981 00021E1F 48 03 50 50 shll $3,r0,r0
1019: 982 00021E23 0d e000000004 effffff78e movl _logf_1_data+4(r0),_sgl_expected
1020: 983 00021E2E # /*
1021: 984 00021E2E # * If LOOP ON ERROR is set, this is the loop for this subtest.
1022: 985 00021E2E # * The force loop flag is set after the first error.
1023: 986 00021E2E # */
1024: 987 00021E2E # asm("_logf_6_lp1:");
1025: 988 00021E2E _logf_6_lp1:
1026: 989 00021E2E # asm("movl $0,r0"); /* clear r0 */
1027: 990 00021E2E 0d 00 50 movl $0,r0
1028: 991 00021E31 # asm("ldf _sgl_ld_acc"); /* load the Acc. */
1029: 992 00021E31 06 effffff785 ldf _sgl_ld_acc
1030: 993 00021E37 # asm("logf"); /* get the log */
1031: 994 00021E37 35 logf
1032: 995 00021E38 # asm("addf r0"); /* add a zero to the acc */
1033: 996 00021E38 c6 50 addf r0
1034: 997 00021E3A # asm("stf _sgl_st_acc"); /* store the result */
1035: 998 00021E3A 26 effffff77c stf _sgl_st_acc
1036: 999 00021E40 # if( force_loop )
1037: 1000 00021E40 5d effffff776 tstl _force_loop
1038: 1001 00021E46 31 02 jeql L338
1039: 1002 00021E48 # asm("brb _logf_6_lp1");; /* loop on the error */
1040: 1003 00021E48 11 e4 brb _logf_6_lp1
1041: 1004 00021E4A L338:
1042: 1005 00021E4A # /*
1043: 1006 00021E4A # * end error loop - test the results
1044: 1007 00021E4A # */
1045: 1008 00021E4A # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1046: 1009 00021E4A 1d effffff76c effffff767 cmpl _sgl_st_acc,_sgl_expected
1047: 1010 00021E55 21 03 13 00cf jeql L339
1048: 1011 00021E5A # errcnt++; /* bump the error count */
1049: 1012 00021E5A 6d effffff75c incl _errcnt
1050: 1013 00021E60 # if( prt_error ) {
1051: 1014 00021E60 5d effffff756 tstl _prt_error
1052: 1015 00021E66 21 03 13 009b jeql L340
1053: 1016 00021E6B # writes(" \n"); /* start a new print line */
1054: 1017 00021E6B .data 1
1055: 1018 00000cab * L341:
1056: 1019 00000cab * 200A00 .ascii " \12\0"
1057: 1020 00000cae * .text
1058: 1021 00021E6B dd 8f00000cab pushl $L341
1059: 1022 00021E71 fe 08 effffff744 callf $8,_writes
1060: 1023 00021E78 # writes("cycle: ");
1061: 1024 00021E78 .data 1
1062: 1025 00000cae * L342:
1063: 1026 00000cae * 6379636C653A2000 .ascii "cycle: \0"
1064: 1027 00000cb6 * .text
1065: 1028 00021E78 dd 8f00000cae pushl $L342
1066: 1029 00021E7E fe 08 effffff737 callf $8,_writes
1067: 1030 00021E85 # writed( cycle );
1068: 1031 00021E85 dd effffff731 pushl _cycle
1069: 1032 00021E8B fe 08 effffff72a callf $8,_writed
1070: 1033 00021E92 # writes(" LOGF test ");
1071: 1034 00021E92 .data 1
1072: 1035 00000cb6 * L343:
1073: 1036 00000cb6 * 2020204C4F474620746573742 .ascii " LOGF test \0"
1074: 000
1075: 1037 00000cc4 * .text
1076: 1038 00021E92 dd 8f00000cb6 pushl $L343
1077: 1039 00021E98 fe 08 effffff71d callf $8,_writes
1078: 1040 00021E9F # writed( test_no );
1079: 1041 00021E9F dd effffff717 pushl _test_no
1080: 1042 00021EA5 fe 08 effffff710 callf $8,_writed
1081: 1043 00021EAC # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n");
1082: 1044 00021EAC .data 1
1083: 1045 00000cc4 * L344:
1084: 1046 00000cc4 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0"
1085: 8506970656420457869742920
1086: 2D204241442046494E414C204
1087: 143430A00
1088: 1047 00000cee * .text
1089: 1048 00021EAC dd 8f00000cc4 pushl $L344
1090: 1049 00021EB2 fe 08 effffff703 callf $8,_writes
1091: 1050 00021EB9 # print_logf_data();
1092: 1051 00021EB9 fe 04 ef00000076 callf $4,_print_logf_data
1093: 1052 00021EC0 # writes(", data index = ");
1094: 1053 00021EC0 .data 1
1095: 1054 00000cee * L345:
1096: 1055 00000cee * 2C20206461746120696E64657 .ascii ", data index = \0"
1097: 8203D2000
1098: 1056 00000cff * .text
1099: 1057 00021EC0 dd 8f00000cee pushl $L345
1100: 1058 00021EC6 fe 08 effffff6ef callf $8,_writes
1101: 1059 00021ECD # writed( index );
1102: 1060 00021ECD dd effffff6e9 pushl _index
1103: 1061 00021ED3 fe 08 effffff6e2 callf $8,_writed
1104: 1062 00021EDA # writec('\n');
1105: 1063 00021EDA dd 0a pushl $10
1106: 1064 00021EDC fe 08 effffff6d9 callf $8,_writec
1107: 1065 00021EE3 # writes(" expected = ");
1108: 1066 00021EE3 .data 1
1109: 1067 00000cff * L346:
1110: 1068 00000cff * 2020202020202020202020202 .ascii " expected = \0"
1111: 0202020202020202020202020
1112: 206578706563746564203D200
1113: 0
1114: 1069 00000d25 * .text
1115: 1070 00021EE3 dd 8f00000cff pushl $L346
1116: 1071 00021EE9 fe 08 effffff6cc callf $8,_writes
1117: 1072 00021EF0 # write32h( sgl_expected );
1118: 1073 00021EF0 dd effffff6c6 pushl _sgl_expected
1119: 1074 00021EF6 fe 08 effffff6bf callf $8,_write32h
1120: 1075 00021EFD # writec('\n');
1121: 1076 00021EFD dd 0a pushl $10
1122: 1077 00021EFF fe 08 effffff6b6 callf $8,_writec
1123: 1078 00021F06 # }
1124: 1079 00021F06 # if( halt_flg )
1125: 1080 00021F06 L340:
1126: 1081 00021F06 5d effffff6b0 tstl _halt_flg
1127: 1082 00021F0C 31 09 jeql L347
1128: 1083 00021F0E # logf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1129: 1084 00021F0E dd 01 pushl $1
1130: 1085 00021F10 fe 08 ef0000005b callf $8,_logf_er_halt
1131: 1086 00021F17 # if( loop_on_err ) {
1132: 1087 00021F17 L347:
1133: 1088 00021F17 5d effffff69f tstl _loop_on_err
1134: 1089 00021F1D 31 0a jeql L348
1135: 1090 00021F1F # force_loop = TRUE; /* set the force loop flag */
1136: 1091 00021F1F 0d 01 effffff696 movl $1,_force_loop
1137: 1092 00021F26 # asm("brw _logf_6_lp1");; /* and loop on the error */
1138: 1093 00021F26 13 ff05 brw _logf_6_lp1
1139: 1094 00021F29 # } /* end of loop on error */
1140: 1095 00021F29 # } /* end of compare error */
1141: 1096 00021F29 L348:
1142: 1097 00021F29 # } /* end of WHILE loop */
1143: 1098 00021F29 L339:
1144: 1099 00021F29 L335:
1145: 1100 00021F29 6d effffff68d incl _index
1146: 1101 00021F2F 13 fec0 jbr L337
1147: 1102 00021F32 L336:
1148: 1103 00021F32 # } /* end of subtest 6 */
1149: 1104 00021F32 40 ret#2
1150: 1105 00021F33 .set L331,0x0
1151: 1106 00021F33 L333:
1152: 1107 00021F33 13 fea9 jbr L334
1153: 1108 00021F36 .data
1154: 1109 00000a60 * .text
1155: 1110 00021F36 .align 1
1156: 1111 00021F36 .globl _print_logf_data
1157: 1112 00021F36 _print_logf_data:
1158: 1113 00021F36 0000 .word L349
1159: 1114 00021F38 #
1160: 1115 00021F38 #
1161: 1116 00021F38 # /**************************************************************************
1162: 1117 00021F38 # *
1163: 1118 00021F38 # * PRINT THE DATA AND STORE RESULTS
1164: 1119 00021F38 # *
1165: 1120 00021F38 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1166: 1121 00021F38 # * Acc expected = xxxxxxxx
1167: 1122 00021F38 # **************************************************************************/
1168: 1123 00021F38 # print_logf_data()
1169: 1124 00021F38 # {
1170: 1125 00021F38 11 35 jbr L351
1171: 1126 00021F3A L352:
1172: 1127 00021F3A # writes("initial Acc = ");
1173: 1128 00021F3A .data 1
1174: 1129 00000d25 * L353:
1175: 1130 00000d25 * 696E697469616C20416363203 .ascii "initial Acc = \0"
1176: D2000
1177: 1131 00000d34 * .text
1178: 1132 00021F3A dd 8f00000d25 pushl $L353
1179: 1133 00021F40 fe 08 effffff675 callf $8,_writes
1180: 1134 00021F47 # write32h( sgl_ld_acc );
1181: 1135 00021F47 dd effffff66f pushl _sgl_ld_acc
1182: 1136 00021F4D fe 08 effffff668 callf $8,_write32h
1183: 1137 00021F54 # writes(", final Acc = ");
1184: 1138 00021F54 .data 1
1185: 1139 00000d34 * L354:
1186: 1140 00000d34 * 2C202066696E616C204163632 .ascii ", final Acc = \0"
1187: 03D2000
1188: 1141 00000d44 * .text
1189: 1142 00021F54 dd 8f00000d34 pushl $L354
1190: 1143 00021F5A fe 08 effffff65b callf $8,_writes
1191: 1144 00021F61 # write32h( sgl_st_acc );
1192: 1145 00021F61 dd effffff655 pushl _sgl_st_acc
1193: 1146 00021F67 fe 08 effffff64e callf $8,_write32h
1194: 1147 00021F6E # }
1195: 1148 00021F6E 40 ret#2
1196: 1149 00021F6F .set L349,0x0
1197: 1150 00021F6F L351:
1198: 1151 00021F6F 11 c9 jbr L352
1199: 1152 00021F71 .data
1200: 1153 00000a60 * .text
1201: 1154 00021F71 00 .align 1
1202: 1155 00021F72 .globl _logf_er_halt
1203: 1156 00021F72 _logf_er_halt:
1204: 1157 00021F72 0000 .word L355
1205: 1158 00021F74 #
1206: 1159 00021F74 #
1207: 1160 00021F74 #
1208: 1161 00021F74 # /**************************************************************************
1209: 1162 00021F74 # *
1210: 1163 00021F74 # * HALT ON ERROR ROUTINE
1211: 1164 00021F74 # *
1212: 1165 00021F74 # **************************************************************************/
1213: 1166 00021F74 # logf_er_halt( halt_code )
1214: 1167 00021F74 # int halt_code;
1215: 1168 00021F74 # {
1216: 1169 00021F74 13 00a0 jbr L357
1217: 1170 00021F77 L358:
1218: 1171 00021F77 # sgl_dummy1 = halt_code; /* get the error type */
1219: 1172 00021F77 0d ad04 effffff63d movl 4(fp),_sgl_dummy1
1220: 1173 00021F7F # asm("movl _test_no,r0"); /* r0 = test number */
1221: 1174 00021F7F 0d effffff637 50 movl _test_no,r0
1222: 1175 00021F86 # asm("movl _subtest,r1"); /* r1 = subtest number */
1223: 1176 00021F86 0d effffff630 51 movl _subtest,r1
1224: 1177 00021F8D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1225: 1178 00021F8D 0d effffff629 52 movl _sgl_dummy1,r2
1226: 1179 00021F94 # asm("movl _cycle,r3"); /* r3 = cycle count */
1227: 1180 00021F94 0d effffff622 53 movl _cycle,r3
1228: 1181 00021F9B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1229: 1182 00021F9B 0d effffff61b 54 movl _sgl_ld_acc,r4
1230: 1183 00021FA2 # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */
1231: 1184 00021FA2 0d effffff614 55 movl _sgl_st_acc,r5
1232: 1185 00021FA9 # asm("movl _sgl_expected,r6"); /* r6 = data expected */
1233: 1186 00021FA9 0d effffff60d 56 movl _sgl_expected,r6
1234: 1187 00021FB0 # asm("movl _index,r7"); /* r7 = data index */
1235: 1188 00021FB0 0d effffff606 57 movl _index,r7
1236: 1189 00021FB7 # if( halt_code == BAD_REG_HLT ) {
1237: 1190 00021FB7 1d ad04 02 cmpl 4(fp),$2
1238: 1191 00021FBB 21 3d jneq L359
1239: 1192 00021FBD # sgl_dummy1 = load_regs[index2];
1240: 1193 00021FBD 0d effffff5f9 50 movl _index2,r0
1241: 1194 00021FC4 0d 40effffff5f1 movl _load_regs[r0],_sgl_dummy1
1242: effffff5ec
1243: 1195 00021FD0 # sgl_dummy2 = store_regs[index2];
1244: 1196 00021FD0 0d effffff5e6 50 movl _index2,r0
1245: 1197 00021FD7 0d 40effffff5de movl _store_regs[r0],_sgl_dummy2
1246: effffff5d9
1247: 1198 00021FE3 # asm("movl _index2,r6"); /* r6 = bad register # */
1248: 1199 00021FE3 0d effffff5d3 56 movl _index2,r6
1249: 1200 00021FEA # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */
1250: 1201 00021FEA 0d effffff5cc 57 movl _sgl_dummy2,r7
1251: 1202 00021FF1 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */
1252: 1203 00021FF1 0d effffff5c5 58 movl _sgl_dummy1,r8
1253: 1204 00021FF8 # } else
1254: 1205 00021FF8 11 1b jbr L360
1255: 1206 00021FFA L359:
1256: 1207 00021FFA # if( halt_code == BAD_PSL_HLT ) {
1257: 1208 00021FFA 1d ad04 03 cmpl 4(fp),$3
1258: 1209 00021FFE 21 15 jneq L361
1259: 1210 00022000 # asm("movl _init_psl,r6"); /* r6 = initial PSL */
1260: 1211 00022000 0d effffff5b6 56 movl _init_psl,r6
1261: 1212 00022007 # asm("movl _psl_val,r7"); /* r7 = final PSL */
1262: 1213 00022007 0d effffff5af 57 movl _psl_val,r7
1263: 1214 0002200E # asm("movl _exp_psl,r8"); /* r8 = expected PSL */
1264: 1215 0002200E 0d effffff5a8 58 movl _exp_psl,r8
1265: 1216 00022015 # };
1266: 1217 00022015 L361:
1267: 1218 00022015 L360:
1268: 1219 00022015 # asm("halt"); /* HALT ... */
1269: 1220 00022015 00 halt
1270: 1221 00022016 # }
1271: 1222 00022016 40 ret#2
1272: 1223 00022017 .set L355,0x0
1273: 1224 00022017 L357:
1274: 1225 00022017 13 ff5d jbr L358
1275: 1226 0002201A .data
1276: 1226 000435D6 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.