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