![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf.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 cmpf.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 00000c8c * .text
4 00000000 .align 1
5 00000000 .globl _cmpf
6 00000000 _cmpf:
7 000123B8 0000 .word L215
8 000123BA # #include "fpp_defs.h"
9 000123BA #
10 000123BA #
11 000123BA #
12 000123BA # /***************************************************************************
13 000123BA # *
14 000123BA # * CMPF -COMPARE SGL ACCUMULATOR TO SGL OPERAND
15 000123BA # *
16 000123BA # *****************************************************************************/
17 000123BA # cmpf()
18 000123BA # {
19 000123BA 11 57 jbr L217
20 000123BC L218:
21 000123BC # asm(".globl _cmpf_t");
22 000123BC .globl _cmpf_t
23 000123BC # asm("_cmpf_t:"); /* entry address */
24 000123BC _cmpf_t:
25 000123BC # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26 000123BC 1d effffffff6 01 cmpl _cycle,$1
27 000123C3 21 15 jneq L219
28 000123C5 5d efffffffed tstl _prt_hdrs
29 000123CB 31 0d jeql L219
30 000123CD # {
31 000123CD # writes(" CMPF");
32 000123CD .data 1
33 00000c8c * L221:
34 00000c8c * 20434D504600 .ascii " CMPF\0"
35 00000c92 * .text
36 000123CD dd 8f00000c8c pushl $L221
37 000123D3 fe 08 efffffffde callf $8,_writes
38 000123DA # }
39 000123DA # cmpf_1(); /* test via registers */
40 000123DA L219:
41 000123DA fe 04 ef00000035 callf $4,_cmpf_1
42 000123E1 # cmpf_2(); /* test via cache */
43 000123E1 fe 04 ef00000248 callf $4,_cmpf_2
44 000123E8 # cmpf_3(); /* register corruption test */
45 000123E8 fe 04 ef00000455 callf $4,_cmpf_3
46 000123EF # cmpf_4(); /* acc. corruption test */
47 000123EF fe 04 ef00000628 callf $4,_cmpf_4
48 000123F6 # if( !no_fpp_wcs ) {
49 000123F6 5d efffffffbc tstl _no_fpp_wcs
50 000123FC 21 0e jneq L226
51 000123FE # cmpf_5(); /* pipelined entry test */
52 000123FE fe 04 ef000007a3 callf $4,_cmpf_5
53 00012405 # cmpf_6(); /* pipelined exit test */
54 00012405 fe 04 ef000009b6 callf $4,_cmpf_6
55 0001240C # };
56 0001240C L226:
57 0001240C # asm("jmp *return"); /* return to the test monitor */
58 0001240C 71 ffffffffa6 jmp *return
59 00012412 # }
60 00012412 40 ret#2
61 00012413 .set L215,0x0
62 00012413 L217:
63 00012413 11 a7 jbr L218
64 00012415 .data
65 00000c8c * .text
66 00012415 00 .align 1
67 00012416 .globl _cmpf_1
68 00012416 _cmpf_1:
69 00012416 0000 .word L229
70 00012418 #
71 00012418 #
72 00012418 #
73 00012418 # /****************************************************************************
74 00012418 # *
75 00012418 # * SUBTEST 1 - CMPF status test -register data
76 00012418 # *
77 00012418 # ****************************************************************************/
78 00012418 # cmpf_1()
79 00012418 # {
80 00012418 13 0212 jbr L231
81 0001241B L232:
82 0001241B # force_loop = FALSE;
83 0001241B 4d efffffff97 clrl _force_loop
84 00012421 # subtest = 1;
85 00012421 0d 01 efffffff90 movl $1,_subtest
86 00012428 # index = 0;
87 00012428 4d efffffff8a clrl _index
88 0001242E # do
89 0001242E L235:
90 0001242E # {
91 0001242E # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
92 0001242E 5c 0c efffffff83 50 mull3 $12,_index,r0
93 00012436 0d e000000000 efffffff77 movl _cmpf_1_data(r0),_sgl_value_1
94 00012441 # sgl_value_2 = cmpf_1_data[index].two;
95 00012441 5c 0c efffffff70 50 mull3 $12,_index,r0
96 00012449 0d e000000004 efffffff64 movl _cmpf_1_data+4(r0),_sgl_value_2
97 00012454 # sgl_expected = cmpf_1_data[index].flag; /* get expected results */
98 00012454 5c 0c efffffff5d 50 mull3 $12,_index,r0
99 0001245C 0d e000000008 efffffff51 movl _cmpf_1_data+8(r0),_sgl_expected
100 00012467 # status_index = 0; /* clear the status index */
101 00012467 4d efffffff4b clrl _status_index
102 0001246D # do
103 0001246D L238:
104 0001246D # {
105 0001246D # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
106 0001246D 0d efffffff45 50 movl _status_index,r0
107 00012474 0d 40efffffff3d movl _status_array[r0],_sgl_dummy1
efffffff38
108 00012480 # /*
109 00012480 # * If LOOP ON ERROR is set, this is the loop for this subtest.
110 00012480 # * The force loop flag is set after the first error.
111 00012480 # */
112 00012480 # asm("_cmpf_1_lp1:");
113 00012480 _cmpf_1_lp1:
114 00012480 # asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
115 00012480 0d efffffff32 54 movl _sgl_value_1,r4
116 00012487 # asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
117 00012487 0d efffffff2b 55 movl _sgl_value_2,r5
118 0001248E # asm("ldf r4"); /* load the 1st operand */
119 0001248E 06 54 ldf r4
120 00012490 # asm("tstl _sgl_dummy1"); /* generate initial status */
121 00012490 5d efffffff22 tstl _sgl_dummy1
122 00012496 # asm("movpsl _init_psl"); /* save the initial status */
123 00012496 cd efffffff1c movpsl _init_psl
124 0001249C # asm("cmpf r5"); /* compare the operands */
125 0001249C 36 55 cmpf r5
126 0001249E # asm("movpsl _psl_val"); /* save the final status */
127 0001249E cd efffffff14 movpsl _psl_val
128 000124A4 # asm("stf _sgl_st_acc"); /* save the final acc */
129 000124A4 26 efffffff0e stf _sgl_st_acc
130 000124AA # if( force_loop ) /* loop? */
131 000124AA 5d efffffff08 tstl _force_loop
132 000124B0 31 02 jeql L239
133 000124B2 # asm("brb _cmpf_1_lp1");; /* run the loop again */
134 000124B2 11 cc brb _cmpf_1_lp1
135 000124B4 L239:
136 000124B4 # exp_psl = init_psl; /* get the initial PSL */
137 000124B4 0d effffffefe effffffef9 movl _init_psl,_exp_psl
138 000124BF # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
139 000124BF ac 88f3 effffffef1 andl2 $-13,_exp_psl
140 000124C7 # if( sgl_expected == ZERO )
141 000124C7 1d effffffeeb 04 cmpl _sgl_expected,$4
142 000124CE 21 07 jneq L240
143 000124D0 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
144 000124D0 8c 04 effffffee1 orl2 $4,_exp_psl
145 000124D7 # if( sgl_expected == NEGATIVE )
146 000124D7 L240:
147 000124D7 1d effffffedb 08 cmpl _sgl_expected,$8
148 000124DE 21 07 jneq L241
149 000124E0 # exp_psl |= PSL_N; /* expect the NEG bit set */
150 000124E0 8c 08 effffffed1 orl2 $8,_exp_psl
151 000124E7 # if( psl_val != exp_psl ) { /* COMPARE the values */
152 000124E7 L241:
153 000124E7 1d effffffecb effffffec6 cmpl _psl_val,_exp_psl
154 000124F2 21 03 13 0107 jeql L242
155 000124F7 # errcnt++; /* bump the error count */
156 000124F7 6d effffffebb incl _errcnt
157 000124FD # if ( prt_error ) {
158 000124FD 5d effffffeb5 tstl _prt_error
159 00012503 21 03 13 00d3 jeql L243
160 00012508 # writes(" \n"); /* start a new print line */
161 00012508 .data 1
162 00000c92 * L244:
163 00000c92 * 200A00 .ascii " \12\0"
164 00000c95 * .text
165 00012508 dd 8f00000c92 pushl $L244
166 0001250E fe 08 effffffea3 callf $8,_writes
167 00012515 # writes("cycle: ");
168 00012515 .data 1
169 00000c95 * L245:
170 00000c95 * 6379636C653A2000 .ascii "cycle: \0"
171 00000c9d * .text
172 00012515 dd 8f00000c95 pushl $L245
173 0001251B fe 08 effffffe96 callf $8,_writes
174 00012522 # writed( cycle );
175 00012522 dd effffffe90 pushl _cycle
176 00012528 fe 08 effffffe89 callf $8,_writed
177 0001252F # writes(" CMPF test ");
178 0001252F .data 1
179 00000c9d * L247:
180 00000c9d * 2020434D50462074657374200 .ascii " CMPF test \0"
0
181 00000caa * .text
182 0001252F dd 8f00000c9d pushl $L247
183 00012535 fe 08 effffffe7c callf $8,_writes
184 0001253C # writed( test_no );
185 0001253C dd effffffe76 pushl _test_no
186 00012542 fe 08 effffffe6f callf $8,_writed
187 00012549 # writes(", subtest 1 (Reg. Data) - BAD FINAL PSL\n");
188 00012549 .data 1
189 00000caa * L248:
190 00000caa * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL PSL\12\0"
85265672E204461746129202D
204241442046494E414C20505
34C0A00
191 00000cd3 * .text
192 00012549 dd 8f00000caa pushl $L248
193 0001254F fe 08 effffffe62 callf $8,_writes
194 00012556 # print_cmpf_data();
195 00012556 fe 04 ef000009fb callf $4,_print_cmpf_data
196 0001255D # writes(", data index = ");
197 0001255D .data 1
198 00000cd3 * L250:
199 00000cd3 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
200 00000ce4 * .text
201 0001255D dd 8f00000cd3 pushl $L250
202 00012563 fe 08 effffffe4e callf $8,_writes
203 0001256A # writed( index );
204 0001256A dd effffffe48 pushl _index
205 00012570 fe 08 effffffe41 callf $8,_writed
206 00012577 # writec('\n');
207 00012577 dd 0a pushl $10
208 00012579 fe 08 effffffe38 callf $8,_writec
209 00012580 # writes("initial PSL = ");
210 00012580 .data 1
211 00000ce4 * L252:
212 00000ce4 * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
213 00000cf3 * .text
214 00012580 dd 8f00000ce4 pushl $L252
215 00012586 fe 08 effffffe2b callf $8,_writes
216 0001258D # write32h( init_psl );
217 0001258D dd effffffe25 pushl _init_psl
218 00012593 fe 08 effffffe1e callf $8,_write32h
219 0001259A # writes(", final PSL = ");
220 0001259A .data 1
221 00000cf3 * L254:
222 00000cf3 * 2C2066696E616C2050534C203 .ascii ", final PSL = \0"
D2000
223 00000d02 * .text
224 0001259A dd 8f00000cf3 pushl $L254
225 000125A0 fe 08 effffffe11 callf $8,_writes
226 000125A7 # write32h( psl_val );
227 000125A7 dd effffffe0b pushl _psl_val
228 000125AD fe 08 effffffe04 callf $8,_write32h
229 000125B4 # writes(", expected PSL = ");
230 000125B4 .data 1
231 00000d02 * L255:
232 00000d02 * 2C20657870656374656420505 .ascii ", expected PSL = \0"
34C203D2000
233 00000d14 * .text
234 000125B4 dd 8f00000d02 pushl $L255
235 000125BA fe 08 effffffdf7 callf $8,_writes
236 000125C1 # write32h( exp_psl );
237 000125C1 dd effffffdf1 pushl _exp_psl
238 000125C7 fe 08 effffffdea callf $8,_write32h
239 000125CE # writes("\n");
240 000125CE .data 1
241 00000d14 * L256:
242 00000d14 * 0A00 .ascii "\12\0"
243 00000d16 * .text
244 000125CE dd 8f00000d14 pushl $L256
245 000125D4 fe 08 effffffddd callf $8,_writes
246 000125DB # }
247 000125DB # if ( halt_flg )
248 000125DB L243:
249 000125DB 5d effffffdd7 tstl _halt_flg
250 000125E1 31 09 jeql L257
251 000125E3 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
252 000125E3 dd 03 pushl $3
253 000125E5 fe 08 ef000009a8 callf $8,_cmpf_er_halt
254 000125EC # if ( loop_on_err ) {
255 000125EC L257:
256 000125EC 5d effffffdc6 tstl _loop_on_err
257 000125F2 31 0a jeql L259
258 000125F4 # force_loop = TRUE; /* set the force loop flag */
259 000125F4 0d 01 effffffdbd movl $1,_force_loop
260 000125FB # asm("brw _cmpf_1_lp1"); /* and loop on the error */
261 000125FB 13 fe82 brw _cmpf_1_lp1
262 000125FE # } /* end of loop on error */
263 000125FE # } /* end of compare error */
264 000125FE L259:
265 000125FE # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
266 000125FE L242:
267 000125FE L237:
268 000125FE 6d effffffdb4 incl _status_index
269 00012604 0d effffffdae 50 movl _status_index,r0
270 0001260B 1d 50 03 cmpl r0,$3
271 0001260E 81 03 13 fe5a jlss L238
272 00012613 L236:
273 00012613 # } while( index++ < max_cmpf_1_index);/* end of data loop */
274 00012613 L234:
275 00012613 0d effffffd9f 50 movl _index,r0
276 0001261A 6d effffffd98 incl _index
277 00012620 1d 50 effffffd91 cmpl r0,_max_cmpf_1_index
278 00012627 81 03 13 fe02 jlss L235
279 0001262C L233:
280 0001262C # } /* end of subtest 1 */
281 0001262C 40 ret#2
282 0001262D .set L229,0x0
283 0001262D L231:
284 0001262D 13 fdeb jbr L232
285 00012630 .data
286 00000c8c * .text
287 00012630 .align 1
288 00012630 .globl _cmpf_2
289 00012630 _cmpf_2:
290 00012630 0000 .word L260
291 00012632 #
292 00012632 #
293 00012632 #
294 00012632 # /****************************************************************************
295 00012632 # *
296 00012632 # * SUBTEST 2 - CMPF status test -cache data
297 00012632 # *
298 00012632 # ****************************************************************************/
299 00012632 # cmpf_2()
300 00012632 # {
301 00012632 13 020c jbr L262
302 00012635 L263:
303 00012635 # force_loop = FALSE;
304 00012635 4d effffffd7d clrl _force_loop
305 0001263B # subtest = 2;
306 0001263B 0d 02 effffffd76 movl $2,_subtest
307 00012642 # index = 0;
308 00012642 4d effffffd70 clrl _index
309 00012648 # do
310 00012648 L266:
311 00012648 # {
312 00012648 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
313 00012648 5c 0c effffffd69 50 mull3 $12,_index,r0
314 00012650 0d e000000000 effffffd5d movl _cmpf_1_data(r0),_sgl_value_1
315 0001265B # sgl_value_2 = cmpf_1_data[index].two;
316 0001265B 5c 0c effffffd56 50 mull3 $12,_index,r0
317 00012663 0d e000000004 effffffd4a movl _cmpf_1_data+4(r0),_sgl_value_2
318 0001266E # sgl_expected = cmpf_1_data[index].flag;/* get expected results */
319 0001266E 5c 0c effffffd43 50 mull3 $12,_index,r0
320 00012676 0d e000000008 effffffd37 movl _cmpf_1_data+8(r0),_sgl_expected
321 00012681 # status_index = 0; /* clear the status index */
322 00012681 4d effffffd31 clrl _status_index
323 00012687 # do
324 00012687 L269:
325 00012687 # {
326 00012687 # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
327 00012687 0d effffffd2b 50 movl _status_index,r0
328 0001268E 0d 40effffffd23 movl _status_array[r0],_sgl_dummy1
effffffd1e
329 0001269A # /*
330 0001269A # * If LOOP ON ERROR is set, this is the loop for this subtest.
331 0001269A # * The force loop flag is set after the first error.
332 0001269A # */
333 0001269A # asm("_cmpf_2_lp1:");
334 0001269A _cmpf_2_lp1:
335 0001269A # asm("ldf _sgl_value_1"); /* load the 1st operand */
336 0001269A 06 effffffd18 ldf _sgl_value_1
337 000126A0 # asm("tstl _sgl_dummy1"); /* generate initial status */
338 000126A0 5d effffffd12 tstl _sgl_dummy1
339 000126A6 # asm("movpsl _init_psl"); /* save the initial status */
340 000126A6 cd effffffd0c movpsl _init_psl
341 000126AC # asm("cmpf _sgl_value_2"); /* compare the operands */
342 000126AC 36 effffffd06 cmpf _sgl_value_2
343 000126B2 # asm("movpsl _psl_val"); /* save the final status */
344 000126B2 cd effffffd00 movpsl _psl_val
345 000126B8 # asm("stf _sgl_st_acc"); /* save the final acc */
346 000126B8 26 effffffcfa stf _sgl_st_acc
347 000126BE # if( force_loop ) /* loop? */
348 000126BE 5d effffffcf4 tstl _force_loop
349 000126C4 31 02 jeql L270
350 000126C6 # asm("brb _cmpf_2_lp1");; /* run the loop again */
351 000126C6 11 d2 brb _cmpf_2_lp1
352 000126C8 L270:
353 000126C8 # exp_psl = init_psl; /* get the initial PSL */
354 000126C8 0d effffffcea effffffce5 movl _init_psl,_exp_psl
355 000126D3 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
356 000126D3 ac 88f3 effffffcdd andl2 $-13,_exp_psl
357 000126DB # if( sgl_expected == ZERO )
358 000126DB 1d effffffcd7 04 cmpl _sgl_expected,$4
359 000126E2 21 07 jneq L271
360 000126E4 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
361 000126E4 8c 04 effffffccd orl2 $4,_exp_psl
362 000126EB # if( sgl_expected == NEGATIVE )
363 000126EB L271:
364 000126EB 1d effffffcc7 08 cmpl _sgl_expected,$8
365 000126F2 21 07 jneq L272
366 000126F4 # exp_psl |= PSL_N; /* expect the NEG bit set */
367 000126F4 8c 08 effffffcbd orl2 $8,_exp_psl
368 000126FB # if( psl_val != exp_psl ) { /* COMPARE the values */
369 000126FB L272:
370 000126FB 1d effffffcb7 effffffcb2 cmpl _psl_val,_exp_psl
371 00012706 21 03 13 0107 jeql L273
372 0001270B # errcnt++; /* bump the error count */
373 0001270B 6d effffffca7 incl _errcnt
374 00012711 # if ( prt_error ) {
375 00012711 5d effffffca1 tstl _prt_error
376 00012717 21 03 13 00d3 jeql L274
377 0001271C # writes(" \n"); /* start a new print line */
378 0001271C .data 1
379 00000d16 * L275:
380 00000d16 * 200A00 .ascii " \12\0"
381 00000d19 * .text
382 0001271C dd 8f00000d16 pushl $L275
383 00012722 fe 08 effffffc8f callf $8,_writes
384 00012729 # writes("cycle: ");
385 00012729 .data 1
386 00000d19 * L276:
387 00000d19 * 6379636C653A2000 .ascii "cycle: \0"
388 00000d21 * .text
389 00012729 dd 8f00000d19 pushl $L276
390 0001272F fe 08 effffffc82 callf $8,_writes
391 00012736 # writed( cycle );
392 00012736 dd effffffc7c pushl _cycle
393 0001273C fe 08 effffffc75 callf $8,_writed
394 00012743 # writes(" CMPF test ");
395 00012743 .data 1
396 00000d21 * L277:
397 00000d21 * 2020434D50462074657374200 .ascii " CMPF test \0"
0
398 00000d2e * .text
399 00012743 dd 8f00000d21 pushl $L277
400 00012749 fe 08 effffffc68 callf $8,_writes
401 00012750 # writed( test_no );
402 00012750 dd effffffc62 pushl _test_no
403 00012756 fe 08 effffffc5b callf $8,_writed
404 0001275D # writes(", subtest 2 (Cache Data) - BAD FINAL PSL\n");
405 0001275D .data 1
406 00000d2e * L278:
407 00000d2e * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL PSL\12\0"
8436163686520446174612920
2D204241442046494E414C205
0534C0A00
408 00000d58 * .text
409 0001275D dd 8f00000d2e pushl $L278
410 00012763 fe 08 effffffc4e callf $8,_writes
411 0001276A # print_cmpf_data();
412 0001276A fe 04 ef000007e7 callf $4,_print_cmpf_data
413 00012771 # writes(", data index = ");
414 00012771 .data 1
415 00000d58 * L279:
416 00000d58 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
417 00000d69 * .text
418 00012771 dd 8f00000d58 pushl $L279
419 00012777 fe 08 effffffc3a callf $8,_writes
420 0001277E # writed( index );
421 0001277E dd effffffc34 pushl _index
422 00012784 fe 08 effffffc2d callf $8,_writed
423 0001278B # writec('\n');
424 0001278B dd 0a pushl $10
425 0001278D fe 08 effffffc24 callf $8,_writec
426 00012794 # writes("initial PSL = ");
427 00012794 .data 1
428 00000d69 * L280:
429 00000d69 * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
430 00000d78 * .text
431 00012794 dd 8f00000d69 pushl $L280
432 0001279A fe 08 effffffc17 callf $8,_writes
433 000127A1 # write32h( init_psl );
434 000127A1 dd effffffc11 pushl _init_psl
435 000127A7 fe 08 effffffc0a callf $8,_write32h
436 000127AE # writes(", final PSL = ");
437 000127AE .data 1
438 00000d78 * L281:
439 00000d78 * 2C2066696E616C2050534C203 .ascii ", final PSL = \0"
D2000
440 00000d87 * .text
441 000127AE dd 8f00000d78 pushl $L281
442 000127B4 fe 08 effffffbfd callf $8,_writes
443 000127BB # write32h( psl_val );
444 000127BB dd effffffbf7 pushl _psl_val
445 000127C1 fe 08 effffffbf0 callf $8,_write32h
446 000127C8 # writes(", expected PSL = ");
447 000127C8 .data 1
448 00000d87 * L282:
449 00000d87 * 2C20657870656374656420505 .ascii ", expected PSL = \0"
34C203D2000
450 00000d99 * .text
451 000127C8 dd 8f00000d87 pushl $L282
452 000127CE fe 08 effffffbe3 callf $8,_writes
453 000127D5 # write32h( exp_psl );
454 000127D5 dd effffffbdd pushl _exp_psl
455 000127DB fe 08 effffffbd6 callf $8,_write32h
456 000127E2 # writes("\n");
457 000127E2 .data 1
458 00000d99 * L283:
459 00000d99 * 0A00 .ascii "\12\0"
460 00000d9b * .text
461 000127E2 dd 8f00000d99 pushl $L283
462 000127E8 fe 08 effffffbc9 callf $8,_writes
463 000127EF # }
464 000127EF # if ( halt_flg )
465 000127EF L274:
466 000127EF 5d effffffbc3 tstl _halt_flg
467 000127F5 31 09 jeql L284
468 000127F7 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
469 000127F7 dd 03 pushl $3
470 000127F9 fe 08 ef00000794 callf $8,_cmpf_er_halt
471 00012800 # if ( loop_on_err ) {
472 00012800 L284:
473 00012800 5d effffffbb2 tstl _loop_on_err
474 00012806 31 0a jeql L285
475 00012808 # force_loop = TRUE; /* set the force loop flag */
476 00012808 0d 01 effffffba9 movl $1,_force_loop
477 0001280F # asm("brw _cmpf_2_lp1"); /* and loop on the error */
478 0001280F 13 fe88 brw _cmpf_2_lp1
479 00012812 # } /* end of loop on error */
480 00012812 # } /* end of compare error */
481 00012812 L285:
482 00012812 # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
483 00012812 L273:
484 00012812 L268:
485 00012812 6d effffffba0 incl _status_index
486 00012818 0d effffffb9a 50 movl _status_index,r0
487 0001281F 1d 50 03 cmpl r0,$3
488 00012822 81 03 13 fe60 jlss L269
489 00012827 L267:
490 00012827 # } while( index++ < max_cmpf_1_index);/* end of data loop */
491 00012827 L265:
492 00012827 0d effffffb8b 50 movl _index,r0
493 0001282E 6d effffffb84 incl _index
494 00012834 1d 50 effffffb7d cmpl r0,_max_cmpf_1_index
495 0001283B 81 03 13 fe08 jlss L266
496 00012840 L264:
497 00012840 # } /* end of subtest 2 */
498 00012840 40 ret#2
499 00012841 .set L260,0x0
500 00012841 L262:
501 00012841 13 fdf1 jbr L263
502 00012844 .data
503 00000c8c * .text
504 00012844 .align 1
505 00012844 .globl _cmpf_3
506 00012844 _cmpf_3:
507 00012844 0000 .word L286
508 00012846 #
509 00012846 #
510 00012846 #
511 00012846 # /************************************************************************
512 00012846 # *
513 00012846 # * SUBTEST 3 - Check for register corruption
514 00012846 # *
515 00012846 # ************************************************************************/
516 00012846 # cmpf_3()
517 00012846 # {
518 00012846 13 01d2 jbr L288
519 00012849 L289:
520 00012849 # force_loop = FALSE; /* clear force_loop flg */
521 00012849 4d effffffb69 clrl _force_loop
522 0001284F # subtest = 3;
523 0001284F 0d 03 effffffb62 movl $3,_subtest
524 00012856 # fill_reg_buf( load_regs ); /* get pattern for regs */
525 00012856 dd 8f00000000 pushl $_load_regs
526 0001285C fe 08 effffffb55 callf $8,_fill_reg_buf
527 00012863 # index = 0;
528 00012863 4d effffffb4f clrl _index
529 00012869 # do
530 00012869 L293:
531 00012869 # {
532 00012869 # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
533 00012869 5c 0c effffffb48 50 mull3 $12,_index,r0
534 00012871 0d e000000000 effffffb3c movl _cmpf_1_data(r0),_sgl_value_1
535 0001287C # sgl_value_2 = cmpf_1_data[index].two; /* data to compare */
536 0001287C 5c 0c effffffb35 50 mull3 $12,_index,r0
537 00012884 0d e000000004 effffffb29 movl _cmpf_1_data+4(r0),_sgl_value_2
538 0001288F # /*
539 0001288F # * If LOOP ON ERROR is set, this is the loop for this subtest.
540 0001288F # * The force loop flag is set after the first error.
541 0001288F # */
542 0001288F # asm("_cmpf_3_lp1:");
543 0001288F _cmpf_3_lp1:
544 0001288F # asm("ldf _sgl_value_1"); /* LOAD the accumulator */
545 0001288F 06 effffffb23 ldf _sgl_value_1
546 00012895 # asm("nop");
547 00012895 10 nop
548 00012896 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
549 00012896 ab 891fff effffffb19 loadr $0x1fff,_load_regs
550 0001289F # asm("nop");
551 0001289F 10 nop
552 000128A0 # asm("cmpf _sgl_value_2"); /* test the values */
553 000128A0 36 effffffb12 cmpf _sgl_value_2
554 000128A6 # asm("nop");
555 000128A6 10 nop
556 000128A7 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
557 000128A7 bb 891fff effffffb08 storer $0x1fff,_store_regs
558 000128B0 # asm("stf _sgl_st_acc"); /* save the final acc */
559 000128B0 26 effffffb02 stf _sgl_st_acc
560 000128B6 # if( force_loop ) /* loop? */
561 000128B6 5d effffffafc tstl _force_loop
562 000128BC 31 02 jeql L294
563 000128BE # asm("brb _cmpf_3_lp1");; /* run the loop again */
564 000128BE 11 cf brb _cmpf_3_lp1
565 000128C0 L294:
566 000128C0 # /*
567 000128C0 # * Now compare the stored register values to those that were loaded
568 000128C0 # */
569 000128C0 # index2 = 0;
570 000128C0 4d effffffaf2 clrl _index2
571 000128C6 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
572 000128C6 L295:
573 000128C6 0d effffffaec 50 movl _index2,r0
574 000128CD 0d effffffae5 51 movl _index2,r1
575 000128D4 1d 40effffffadd cmpl _load_regs[r0],_store_regs[r1]
41effffffad7
576 000128E1 21 11 jneq L296
577 000128E3 1d effffffacf 0d cmpl _index2,$13
578 000128EA 81 08 jgeq L296
579 000128EC # index2++; /* check reg values */
580 000128EC 6d effffffac6 incl _index2
581 000128F2 11 d2 jbr L295
582 000128F4 L296:
583 000128F4 # if( index2 < 13 ) { /* error if index2 < 13 */
584 000128F4 1d effffffabe 0d cmpl _index2,$13
585 000128FB 91 03 13 0101 jgeq L297
586 00012900 # errcnt++; /* bump the error count */
587 00012900 6d effffffab2 incl _errcnt
588 00012906 # if ( prt_error ) {
589 00012906 5d effffffaac tstl _prt_error
590 0001290C 21 03 13 00cd jeql L298
591 00012911 # writes(" \n"); /* start a new print line */
592 00012911 .data 1
593 00000d9b * L299:
594 00000d9b * 200A00 .ascii " \12\0"
595 00000d9e * .text
596 00012911 dd 8f00000d9b pushl $L299
597 00012917 fe 08 effffffa9a callf $8,_writes
598 0001291E # writes("cycle: ");
599 0001291E .data 1
600 00000d9e * L300:
601 00000d9e * 6379636C653A2000 .ascii "cycle: \0"
602 00000da6 * .text
603 0001291E dd 8f00000d9e pushl $L300
604 00012924 fe 08 effffffa8d callf $8,_writes
605 0001292B # writed( cycle );
606 0001292B dd effffffa87 pushl _cycle
607 00012931 fe 08 effffffa80 callf $8,_writed
608 00012938 # writes(", CMPF test ");
609 00012938 .data 1
610 00000da6 * L301:
611 00000da6 * 2C20434D50462074657374200 .ascii ", CMPF test \0"
0
612 00000db3 * .text
613 00012938 dd 8f00000da6 pushl $L301
614 0001293E fe 08 effffffa73 callf $8,_writes
615 00012945 # writed( test_no );
616 00012945 dd effffffa6d pushl _test_no
617 0001294B fe 08 effffffa66 callf $8,_writed
618 00012952 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n");
619 00012952 .data 1
620 00000db3 * L302:
621 00000db3 * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0"
D204120524547495354455220
574153204D4F4449464945440
A00
622 00000dda * .text
623 00012952 dd 8f00000db3 pushl $L302
624 00012958 fe 08 effffffa59 callf $8,_writes
625 0001295F # print_cmpf_data(); /* print the operands */
626 0001295F fe 04 ef000005f2 callf $4,_print_cmpf_data
627 00012966 # writes("\n");
628 00012966 .data 1
629 00000dda * L303:
630 00000dda * 0A00 .ascii "\12\0"
631 00000ddc * .text
632 00012966 dd 8f00000dda pushl $L303
633 0001296C fe 08 effffffa45 callf $8,_writes
634 00012973 # writes("register "); /* print the information */
635 00012973 .data 1
636 00000ddc * L304:
637 00000ddc * 72656769737465722000 .ascii "register \0"
638 00000de6 * .text
639 00012973 dd 8f00000ddc pushl $L304
640 00012979 fe 08 effffffa38 callf $8,_writes
641 00012980 # writed( index2 ); /* about the corrupted */
642 00012980 dd effffffa32 pushl _index2
643 00012986 fe 08 effffffa2b callf $8,_writed
644 0001298D # writes(" = "); /* register */
645 0001298D .data 1
646 00000de6 * L305:
647 00000de6 * 203D2000 .ascii " = \0"
648 00000dea * .text
649 0001298D dd 8f00000de6 pushl $L305
650 00012993 fe 08 effffffa1e callf $8,_writes
651 0001299A # write32h( store_regs[index2] );
652 0001299A 0d effffffa18 50 movl _index2,r0
653 000129A1 dd 40effffffa10 pushl _store_regs[r0]
654 000129A8 fe 08 effffffa09 callf $8,_write32h
655 000129AF # writes(", should be = ");
656 000129AF .data 1
657 00000dea * L306:
658 00000dea * 2C202073686F756C642062652 .ascii ", should be = \0"
03D2000
659 00000dfa * .text
660 000129AF dd 8f00000dea pushl $L306
661 000129B5 fe 08 effffff9fc callf $8,_writes
662 000129BC # write32h( load_regs[index2] );
663 000129BC 0d effffff9f6 50 movl _index2,r0
664 000129C3 dd 40effffff9ee pushl _load_regs[r0]
665 000129CA fe 08 effffff9e7 callf $8,_write32h
666 000129D1 # writes("\n");
667 000129D1 .data 1
668 00000dfa * L307:
669 00000dfa * 0A00 .ascii "\12\0"
670 00000dfc * .text
671 000129D1 dd 8f00000dfa pushl $L307
672 000129D7 fe 08 effffff9da callf $8,_writes
673 000129DE # }
674 000129DE # if ( halt_flg ) /* halt on error? */
675 000129DE L298:
676 000129DE 5d effffff9d4 tstl _halt_flg
677 000129E4 31 09 jeql L308
678 000129E6 # cmpf_er_halt( BAD_REG_HLT ); /* PC after the halt */
679 000129E6 dd 02 pushl $2
680 000129E8 fe 08 ef000005a5 callf $8,_cmpf_er_halt
681 000129EF # if ( loop_on_err ) {
682 000129EF L308:
683 000129EF 5d effffff9c3 tstl _loop_on_err
684 000129F5 31 0a jeql L309
685 000129F7 # force_loop = TRUE; /* set the force loop flag */
686 000129F7 0d 01 effffff9ba movl $1,_force_loop
687 000129FE # asm("brw _cmpf_3_lp1"); /* and loop on the error */
688 000129FE 13 fe8e brw _cmpf_3_lp1
689 00012A01 # } /* end of loop on error */
690 00012A01 # } /* end of register corruption error */
691 00012A01 L309:
692 00012A01 # } while( index++ < max_cmpf_1_index);/* end of data loop */
693 00012A01 L297:
694 00012A01 L292:
695 00012A01 0d effffff9b1 50 movl _index,r0
696 00012A08 6d effffff9aa incl _index
697 00012A0E 1d 50 effffff9a3 cmpl r0,_max_cmpf_1_index
698 00012A15 81 03 13 fe4f jlss L293
699 00012A1A L291:
700 00012A1A # } /* end of subtest 3 */
701 00012A1A 40 ret#2
702 00012A1B .set L286,0x0
703 00012A1B L288:
704 00012A1B 13 fe2b jbr L289
705 00012A1E .data
706 00000c8c * .text
707 00012A1E .align 1
708 00012A1E .globl _cmpf_4
709 00012A1E _cmpf_4:
710 00012A1E 0000 .word L310
711 00012A20 #
712 00012A20 #
713 00012A20 #
714 00012A20 # /************************************************************************
715 00012A20 # *
716 00012A20 # * SUBTEST 4 - Check for accumulator corruption
717 00012A20 # *
718 00012A20 # ************************************************************************/
719 00012A20 # cmpf_4()
720 00012A20 # {
721 00012A20 13 0181 jbr L312
722 00012A23 L313:
723 00012A23 # force_loop = FALSE; /* clear force_loop flg */
724 00012A23 4d effffff98f clrl _force_loop
725 00012A29 # index = 0;
726 00012A29 4d effffff989 clrl _index
727 00012A2F # do
728 00012A2F L316:
729 00012A2F # {
730 00012A2F # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
731 00012A2F 5c 0c effffff982 50 mull3 $12,_index,r0
732 00012A37 0d e000000000 effffff976 movl _cmpf_1_data(r0),_sgl_value_1
733 00012A42 # sgl_value_2 = cmpf_1_data[index].two;
734 00012A42 5c 0c effffff96f 50 mull3 $12,_index,r0
735 00012A4A 0d e000000004 effffff963 movl _cmpf_1_data+4(r0),_sgl_value_2
736 00012A55 # if( sgl_value_1 & 0x7f800000 )
737 00012A55 3d 8f7f800000 effffff958 bitl $2139095040,_sgl_value_1
738 00012A60 31 0d jeql L317
739 00012A62 # sgl_expected = sgl_value_1; /* expected = loaded */
740 00012A62 0d effffff950 effffff94b movl _sgl_value_1,_sgl_expected
741 00012A6D # else
742 00012A6D 11 06 jbr L318
743 00012A6F L317:
744 00012A6F # sgl_expected = 0; /* expect a '0' stored */
745 00012A6F 4d effffff943 clrl _sgl_expected
746 00012A75 L318:
747 00012A75 # /*
748 00012A75 # * If LOOP ON ERROR is set, this is the loop for this subtest.
749 00012A75 # * The force loop flag is set after the first error.
750 00012A75 # */
751 00012A75 # asm("_cmpf_4_lp1:");
752 00012A75 _cmpf_4_lp1:
753 00012A75 # asm("ldf _sgl_value_1"); /* LOAD the accumulator */
754 00012A75 06 effffff93d ldf _sgl_value_1
755 00012A7B # asm("cmpf _sgl_value_2"); /* test the values */
756 00012A7B 36 effffff937 cmpf _sgl_value_2
757 00012A81 # asm("stf _sgl_st_acc"); /* store the accumulator */
758 00012A81 26 effffff931 stf _sgl_st_acc
759 00012A87 # if( force_loop ) /* loop? */
760 00012A87 5d effffff92b tstl _force_loop
761 00012A8D 31 02 jeql L319
762 00012A8F # asm("brb _cmpf_4_lp1");; /* run the loop again */
763 00012A8F 11 e4 brb _cmpf_4_lp1
764 00012A91 L319:
765 00012A91 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
766 00012A91 1d effffff921 effffff91c cmpl _sgl_st_acc,_sgl_expected
767 00012A9C 21 03 13 00e9 jeql L320
768 00012AA1 # {
769 00012AA1 # errcnt++; /* bump the error count */
770 00012AA1 6d effffff911 incl _errcnt
771 00012AA7 # if ( prt_error ) {
772 00012AA7 5d effffff90b tstl _prt_error
773 00012AAD 21 03 13 00b5 jeql L321
774 00012AB2 # writes(" \n"); /* start a new print line */
775 00012AB2 .data 1
776 00000dfc * L322:
777 00000dfc * 200A00 .ascii " \12\0"
778 00000dff * .text
779 00012AB2 dd 8f00000dfc pushl $L322
780 00012AB8 fe 08 effffff8f9 callf $8,_writes
781 00012ABF # writes("cycle: ");
782 00012ABF .data 1
783 00000dff * L323:
784 00000dff * 6379636C653A2000 .ascii "cycle: \0"
785 00000e07 * .text
786 00012ABF dd 8f00000dff pushl $L323
787 00012AC5 fe 08 effffff8ec callf $8,_writes
788 00012ACC # writed( cycle );
789 00012ACC dd effffff8e6 pushl _cycle
790 00012AD2 fe 08 effffff8df callf $8,_writed
791 00012AD9 # writes(" CMPF test ");
792 00012AD9 .data 1
793 00000e07 * L324:
794 00000e07 * 2020434D50462074657374200 .ascii " CMPF test \0"
0
795 00000e14 * .text
796 00012AD9 dd 8f00000e07 pushl $L324
797 00012ADF fe 08 effffff8d2 callf $8,_writes
798 00012AE6 # writed( test_no );
799 00012AE6 dd effffff8cc pushl _test_no
800 00012AEC fe 08 effffff8c5 callf $8,_writed
801 00012AF3 # writes(", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\n");
802 00012AF3 .data 1
803 00000e14 * L325:
804 00000e14 * 2C20737562746573742034202 .ascii ", subtest 4 (Cache Data) - THE ACC WAS MODIFIED\12\0"
8436163686520446174612920
2D20544845204143432057415
3204D4F4449464945440A00
805 00000e45 * .text
806 00012AF3 dd 8f00000e14 pushl $L325
807 00012AF9 fe 08 effffff8b8 callf $8,_writes
808 00012B00 # print_cmpf_data();
809 00012B00 fe 04 ef00000451 callf $4,_print_cmpf_data
810 00012B07 # writes(", data index = ");
811 00012B07 .data 1
812 00000e45 * L326:
813 00000e45 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
814 00000e56 * .text
815 00012B07 dd 8f00000e45 pushl $L326
816 00012B0D fe 08 effffff8a4 callf $8,_writes
817 00012B14 # writed( index );
818 00012B14 dd effffff89e pushl _index
819 00012B1A fe 08 effffff897 callf $8,_writed
820 00012B21 # writec('\n');
821 00012B21 dd 0a pushl $10
822 00012B23 fe 08 effffff88e callf $8,_writec
823 00012B2A # writes(" final Acc = ");
824 00012B2A .data 1
825 00000e56 * L327:
826 00000e56 * 202066696E616C20416363203 .ascii " final Acc = \0"
D2000
827 00000e65 * .text
828 00012B2A dd 8f00000e56 pushl $L327
829 00012B30 fe 08 effffff881 callf $8,_writes
830 00012B37 # write32h( sgl_st_acc );
831 00012B37 dd effffff87b pushl _sgl_st_acc
832 00012B3D fe 08 effffff874 callf $8,_write32h
833 00012B44 # writes(", Acc expected = ");
834 00012B44 .data 1
835 00000e65 * L328:
836 00000e65 * 2C20204163632065787065637 .ascii ", Acc expected = \0"
46564203D2000
837 00000e78 * .text
838 00012B44 dd 8f00000e65 pushl $L328
839 00012B4A fe 08 effffff867 callf $8,_writes
840 00012B51 # write32h( sgl_expected );
841 00012B51 dd effffff861 pushl _sgl_expected
842 00012B57 fe 08 effffff85a callf $8,_write32h
843 00012B5E # writec('\n');
844 00012B5E dd 0a pushl $10
845 00012B60 fe 08 effffff851 callf $8,_writec
846 00012B67 # }
847 00012B67 # if ( halt_flg ) /* halt on error? */
848 00012B67 L321:
849 00012B67 5d effffff84b tstl _halt_flg
850 00012B6D 31 09 jeql L329
851 00012B6F # cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */
852 00012B6F dd 01 pushl $1
853 00012B71 fe 08 ef0000041c callf $8,_cmpf_er_halt
854 00012B78 # if ( loop_on_err ) {
855 00012B78 L329:
856 00012B78 5d effffff83a tstl _loop_on_err
857 00012B7E 31 0a jeql L330
858 00012B80 # force_loop = TRUE; /* set the force loop flag */
859 00012B80 0d 01 effffff831 movl $1,_force_loop
860 00012B87 # asm("brw _cmpf_4_lp1"); /* and loop on the error */
861 00012B87 13 feeb brw _cmpf_4_lp1
862 00012B8A # } /* end of loop on error */
863 00012B8A # } /* end of compare error */
864 00012B8A L330:
865 00012B8A # } while( index++ < max_cmpf_1_index);/* end of data loop */
866 00012B8A L320:
867 00012B8A L315:
868 00012B8A 0d effffff828 50 movl _index,r0
869 00012B91 6d effffff821 incl _index
870 00012B97 1d 50 effffff81a cmpl r0,_max_cmpf_1_index
871 00012B9E 81 03 13 fe8c jlss L316
872 00012BA3 L314:
873 00012BA3 # } /* end of subtest 4 */
874 00012BA3 40 ret#2
875 00012BA4 .set L310,0x0
876 00012BA4 L312:
877 00012BA4 13 fe7c jbr L313
878 00012BA7 .data
879 00000c8c * .text
880 00012BA7 00 .align 1
881 00012BA8 .globl _cmpf_5
882 00012BA8 _cmpf_5:
883 00012BA8 0000 .word L331
884 00012BAA #
885 00012BAA #
886 00012BAA #
887 00012BAA # /****************************************************************************
888 00012BAA # *
889 00012BAA # * SUBTEST 5 - CMPF status test - piped entry
890 00012BAA # *
891 00012BAA # ****************************************************************************/
892 00012BAA # cmpf_5()
893 00012BAA # {
894 00012BAA 13 0211 jbr L333
895 00012BAD L334:
896 00012BAD # force_loop = FALSE;
897 00012BAD 4d effffff805 clrl _force_loop
898 00012BB3 # subtest = 5;
899 00012BB3 0d 05 effffff7fe movl $5,_subtest
900 00012BBA # index = 0;
901 00012BBA 4d effffff7f8 clrl _index
902 00012BC0 # do
903 00012BC0 L337:
904 00012BC0 # {
905 00012BC0 # sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
906 00012BC0 5c 0c effffff7f1 50 mull3 $12,_index,r0
907 00012BC8 0d e000000000 effffff7e5 movl _cmpf_1_data(r0),_sgl_value_1
908 00012BD3 # sgl_value_2 = cmpf_1_data[index].two;
909 00012BD3 5c 0c effffff7de 50 mull3 $12,_index,r0
910 00012BDB 0d e000000004 effffff7d2 movl _cmpf_1_data+4(r0),_sgl_value_2
911 00012BE6 # sgl_expected = cmpf_1_data[index].flag;/* get expected results */
912 00012BE6 5c 0c effffff7cb 50 mull3 $12,_index,r0
913 00012BEE 0d e000000008 effffff7bf movl _cmpf_1_data+8(r0),_sgl_expected
914 00012BF9 # status_index = 0; /* clear the status index */
915 00012BF9 4d effffff7b9 clrl _status_index
916 00012BFF # do
917 00012BFF L340:
918 00012BFF # {
919 00012BFF # sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
920 00012BFF 0d effffff7b3 50 movl _status_index,r0
921 00012C06 0d 40effffff7ab movl _status_array[r0],_sgl_dummy1
effffff7a6
922 00012C12 # /*
923 00012C12 # * If LOOP ON ERROR is set, this is the loop for this subtest.
924 00012C12 # * The force loop flag is set after the first error.
925 00012C12 # */
926 00012C12 # asm("_cmpf_5_lp1:");
927 00012C12 _cmpf_5_lp1:
928 00012C12 # asm("movl $0,r0"); /* clear r0 */
929 00012C12 0d 00 50 movl $0,r0
930 00012C15 # asm("ldf r0"); /* load the accumulator */
931 00012C15 06 50 ldf r0
932 00012C17 # asm("addf _sgl_value_1"); /* add the 1st operand */
933 00012C17 c6 effffff79b addf _sgl_value_1
934 00012C1D # asm("tstl _sgl_dummy1"); /* generate initial status */
935 00012C1D 5d effffff795 tstl _sgl_dummy1
936 00012C23 # asm("movpsl _init_psl"); /* save the initial status */
937 00012C23 cd effffff78f movpsl _init_psl
938 00012C29 # asm("cmpf _sgl_value_2"); /* compare the operands */
939 00012C29 36 effffff789 cmpf _sgl_value_2
940 00012C2F # asm("movpsl _psl_val"); /* save the final status */
941 00012C2F cd effffff783 movpsl _psl_val
942 00012C35 # asm("stf _sgl_st_acc"); /* save the final acc */
943 00012C35 26 effffff77d stf _sgl_st_acc
944 00012C3B # if( force_loop ) /* loop? */
945 00012C3B 5d effffff777 tstl _force_loop
946 00012C41 31 02 jeql L341
947 00012C43 # asm("brb _cmpf_5_lp1");; /* run the loop again */
948 00012C43 11 cd brb _cmpf_5_lp1
949 00012C45 L341:
950 00012C45 # exp_psl = init_psl; /* get the initial PSL */
951 00012C45 0d effffff76d effffff768 movl _init_psl,_exp_psl
952 00012C50 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
953 00012C50 ac 88f3 effffff760 andl2 $-13,_exp_psl
954 00012C58 # if( sgl_expected == ZERO )
955 00012C58 1d effffff75a 04 cmpl _sgl_expected,$4
956 00012C5F 21 07 jneq L342
957 00012C61 # exp_psl |= PSL_Z; /* expect the ZERO bit set */
958 00012C61 8c 04 effffff750 orl2 $4,_exp_psl
959 00012C68 # if( sgl_expected == NEGATIVE )
960 00012C68 L342:
961 00012C68 1d effffff74a 08 cmpl _sgl_expected,$8
962 00012C6F 21 07 jneq L343
963 00012C71 # exp_psl |= PSL_N; /* expect the NEG bit set */
964 00012C71 8c 08 effffff740 orl2 $8,_exp_psl
965 00012C78 # if( psl_val != exp_psl ) { /* COMPARE the values */
966 00012C78 L343:
967 00012C78 1d effffff73a effffff735 cmpl _psl_val,_exp_psl
968 00012C83 21 03 13 0107 jeql L344
969 00012C88 # errcnt++; /* bump the error count */
970 00012C88 6d effffff72a incl _errcnt
971 00012C8E # if ( prt_error ) {
972 00012C8E 5d effffff724 tstl _prt_error
973 00012C94 21 03 13 00d3 jeql L345
974 00012C99 # writes(" \n"); /* start a new print line */
975 00012C99 .data 1
976 00000e78 * L346:
977 00000e78 * 200A00 .ascii " \12\0"
978 00000e7b * .text
979 00012C99 dd 8f00000e78 pushl $L346
980 00012C9F fe 08 effffff712 callf $8,_writes
981 00012CA6 # writes("cycle: ");
982 00012CA6 .data 1
983 00000e7b * L347:
984 00000e7b * 6379636C653A2000 .ascii "cycle: \0"
985 00000e83 * .text
986 00012CA6 dd 8f00000e7b pushl $L347
987 00012CAC fe 08 effffff705 callf $8,_writes
988 00012CB3 # writed( cycle );
989 00012CB3 dd effffff6ff pushl _cycle
990 00012CB9 fe 08 effffff6f8 callf $8,_writed
991 00012CC0 # writes(" CMPF test ");
992 00012CC0 .data 1
993 00000e83 * L348:
994 00000e83 * 2020434D50462074657374200 .ascii " CMPF test \0"
0
995 00000e90 * .text
996 00012CC0 dd 8f00000e83 pushl $L348
997 00012CC6 fe 08 effffff6eb callf $8,_writes
998 00012CCD # writed( test_no );
999 00012CCD dd effffff6e5 pushl _test_no
1000 00012CD3 fe 08 effffff6de callf $8,_writed
1001 00012CDA # writes(", subtest 5 (Piped Entry) - BAD FINAL PSL\n");
1002 00012CDA .data 1
1003 00000e90 * L349:
1004 00000e90 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL PSL\12\0"
8506970656420456E74727929
202D204241442046494E414C2
050534C0A00
1005 00000ebb * .text
1006 00012CDA dd 8f00000e90 pushl $L349
1007 00012CE0 fe 08 effffff6d1 callf $8,_writes
1008 00012CE7 # print_cmpf_data();
1009 00012CE7 fe 04 ef0000026a callf $4,_print_cmpf_data
1010 00012CEE # writes(", data index = ");
1011 00012CEE .data 1
1012 00000ebb * L350:
1013 00000ebb * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
1014 00000ecc * .text
1015 00012CEE dd 8f00000ebb pushl $L350
1016 00012CF4 fe 08 effffff6bd callf $8,_writes
1017 00012CFB # writed( index );
1018 00012CFB dd effffff6b7 pushl _index
1019 00012D01 fe 08 effffff6b0 callf $8,_writed
1020 00012D08 # writec('\n');
1021 00012D08 dd 0a pushl $10
1022 00012D0A fe 08 effffff6a7 callf $8,_writec
1023 00012D11 # writes("initial PSL = ");
1024 00012D11 .data 1
1025 00000ecc * L351:
1026 00000ecc * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
1027 00000edb * .text
1028 00012D11 dd 8f00000ecc pushl $L351
1029 00012D17 fe 08 effffff69a callf $8,_writes
1030 00012D1E # write32h( init_psl );
1031 00012D1E dd effffff694 pushl _init_psl
1032 00012D24 fe 08 effffff68d callf $8,_write32h
1033 00012D2B # writes(", final PSL = ");
1034 00012D2B .data 1
1035 00000edb * L352:
1036 00000edb * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
1037 00000eeb * .text
1038 00012D2B dd 8f00000edb pushl $L352
1039 00012D31 fe 08 effffff680 callf $8,_writes
1040 00012D38 # write32h( psl_val );
1041 00012D38 dd effffff67a pushl _psl_val
1042 00012D3E fe 08 effffff673 callf $8,_write32h
1043 00012D45 # writes(", expected PSL = ");
1044 00012D45 .data 1
1045 00000eeb * L353:
1046 00000eeb * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
1047 00000efe * .text
1048 00012D45 dd 8f00000eeb pushl $L353
1049 00012D4B fe 08 effffff666 callf $8,_writes
1050 00012D52 # write32h( exp_psl );
1051 00012D52 dd effffff660 pushl _exp_psl
1052 00012D58 fe 08 effffff659 callf $8,_write32h
1053 00012D5F # writes("\n");
1054 00012D5F .data 1
1055 00000efe * L354:
1056 00000efe * 0A00 .ascii "\12\0"
1057 00000f00 * .text
1058 00012D5F dd 8f00000efe pushl $L354
1059 00012D65 fe 08 effffff64c callf $8,_writes
1060 00012D6C # }
1061 00012D6C # if ( halt_flg )
1062 00012D6C L345:
1063 00012D6C 5d effffff646 tstl _halt_flg
1064 00012D72 31 09 jeql L355
1065 00012D74 # cmpf_er_halt( BAD_PSL_HLT ); /* halt on the error */
1066 00012D74 dd 03 pushl $3
1067 00012D76 fe 08 ef00000217 callf $8,_cmpf_er_halt
1068 00012D7D # if ( loop_on_err ) {
1069 00012D7D L355:
1070 00012D7D 5d effffff635 tstl _loop_on_err
1071 00012D83 31 0a jeql L356
1072 00012D85 # force_loop = TRUE; /* set the force loop flag */
1073 00012D85 0d 01 effffff62c movl $1,_force_loop
1074 00012D8C # asm("brw _cmpf_5_lp1"); /* and loop on the error */
1075 00012D8C 13 fe83 brw _cmpf_5_lp1
1076 00012D8F # } /* end of loop on error */
1077 00012D8F # } /* end of compare error */
1078 00012D8F L356:
1079 00012D8F # } while ( ++status_index < 3 ); /* end of PSL WHILE loop */
1080 00012D8F L344:
1081 00012D8F L339:
1082 00012D8F 6d effffff623 incl _status_index
1083 00012D95 0d effffff61d 50 movl _status_index,r0
1084 00012D9C 1d 50 03 cmpl r0,$3
1085 00012D9F 81 03 13 fe5b jlss L340
1086 00012DA4 L338:
1087 00012DA4 # } while( index++ < max_cmpf_1_index);/* end of data loop */
1088 00012DA4 L336:
1089 00012DA4 0d effffff60e 50 movl _index,r0
1090 00012DAB 6d effffff607 incl _index
1091 00012DB1 1d 50 effffff600 cmpl r0,_max_cmpf_1_index
1092 00012DB8 81 03 13 fe03 jlss L337
1093 00012DBD L335:
1094 00012DBD # } /* end of subtest 5 */
1095 00012DBD 40 ret#2
1096 00012DBE .set L331,0x0
1097 00012DBE L333:
1098 00012DBE 13 fdec jbr L334
1099 00012DC1 .data
1100 00000c8c * .text
1101 00012DC1 00 .align 1
1102 00012DC2 .globl _cmpf_6
1103 00012DC2 _cmpf_6:
1104 00012DC2 0000 .word L357
1105 00012DC4 #
1106 00012DC4 #
1107 00012DC4 #
1108 00012DC4 # /****************************************************************************
1109 00012DC4 # *
1110 00012DC4 # * SUBTEST 6 - CMPF status test -piped exit
1111 00012DC4 # *
1112 00012DC4 # ****************************************************************************/
1113 00012DC4 # cmpf_6()
1114 00012DC4 # {
1115 00012DC4 13 018d jbr L359
1116 00012DC7 L360:
1117 00012DC7 # force_loop = FALSE;
1118 00012DC7 4d effffff5eb clrl _force_loop
1119 00012DCD # subtest = 2;
1120 00012DCD 0d 02 effffff5e4 movl $2,_subtest
1121 00012DD4 # index = 0;
1122 00012DD4 4d effffff5de clrl _index
1123 00012DDA # do
1124 00012DDA L363:
1125 00012DDA # {
1126 00012DDA # sgl_value_1 = cmpf_1_data[index].one; /* data to load */
1127 00012DDA 5c 0c effffff5d7 50 mull3 $12,_index,r0
1128 00012DE2 0d e000000000 effffff5cb movl _cmpf_1_data(r0),_sgl_value_1
1129 00012DED # sgl_value_2 = cmpf_1_data[index].two;
1130 00012DED 5c 0c effffff5c4 50 mull3 $12,_index,r0
1131 00012DF5 0d e000000004 effffff5b8 movl _cmpf_1_data+4(r0),_sgl_value_2
1132 00012E00 # if( sgl_value_1 & 0x7f800000 )
1133 00012E00 3d 8f7f800000 effffff5ad bitl $2139095040,_sgl_value_1
1134 00012E0B 31 0d jeql L364
1135 00012E0D # sgl_expected = sgl_value_1; /* expected = loaded */
1136 00012E0D 0d effffff5a5 effffff5a0 movl _sgl_value_1,_sgl_expected
1137 00012E18 # else
1138 00012E18 11 06 jbr L365
1139 00012E1A L364:
1140 00012E1A # sgl_expected = 0; /* expect a '0' stored */
1141 00012E1A 4d effffff598 clrl _sgl_expected
1142 00012E20 L365:
1143 00012E20 # /*
1144 00012E20 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1145 00012E20 # * The force loop flag is set after the first error.
1146 00012E20 # */
1147 00012E20 # asm("_cmpf_6_lp1:");
1148 00012E20 _cmpf_6_lp1:
1149 00012E20 # asm("movl $0,r0"); /* clear r0 */
1150 00012E20 0d 00 50 movl $0,r0
1151 00012E23 # asm("ldf _sgl_value_1"); /* load the 1st operand */
1152 00012E23 06 effffff58f ldf _sgl_value_1
1153 00012E29 # asm("cmpf _sgl_value_2"); /* compare the value */
1154 00012E29 36 effffff589 cmpf _sgl_value_2
1155 00012E2F # asm("addf r0"); /* add a zero to the acc */
1156 00012E2F c6 50 addf r0
1157 00012E31 # asm("stf _sgl_st_acc"); /* save the accumulator */
1158 00012E31 26 effffff581 stf _sgl_st_acc
1159 00012E37 # if( force_loop ) /* loop? */
1160 00012E37 5d effffff57b tstl _force_loop
1161 00012E3D 31 02 jeql L366
1162 00012E3F # asm("brb _cmpf_6_lp1");; /* run the loop again */
1163 00012E3F 11 df brb _cmpf_6_lp1
1164 00012E41 L366:
1165 00012E41 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1166 00012E41 1d effffff571 effffff56c cmpl _sgl_st_acc,_sgl_expected
1167 00012E4C 21 03 13 00e9 jeql L367
1168 00012E51 # errcnt++; /* bump the error count */
1169 00012E51 6d effffff561 incl _errcnt
1170 00012E57 # if ( prt_error ) {
1171 00012E57 5d effffff55b tstl _prt_error
1172 00012E5D 21 03 13 00b5 jeql L368
1173 00012E62 # writes(" \n"); /* start a new print line */
1174 00012E62 .data 1
1175 00000f00 * L369:
1176 00000f00 * 200A00 .ascii " \12\0"
1177 00000f03 * .text
1178 00012E62 dd 8f00000f00 pushl $L369
1179 00012E68 fe 08 effffff549 callf $8,_writes
1180 00012E6F # writes("cycle: ");
1181 00012E6F .data 1
1182 00000f03 * L370:
1183 00000f03 * 6379636C653A2000 .ascii "cycle: \0"
1184 00000f0b * .text
1185 00012E6F dd 8f00000f03 pushl $L370
1186 00012E75 fe 08 effffff53c callf $8,_writes
1187 00012E7C # writed( cycle );
1188 00012E7C dd effffff536 pushl _cycle
1189 00012E82 fe 08 effffff52f callf $8,_writed
1190 00012E89 # writes(" CMPF test ");
1191 00012E89 .data 1
1192 00000f0b * L371:
1193 00000f0b * 2020434D50462074657374200 .ascii " CMPF test \0"
0
1194 00000f18 * .text
1195 00012E89 dd 8f00000f0b pushl $L371
1196 00012E8F fe 08 effffff522 callf $8,_writes
1197 00012E96 # writed( test_no );
1198 00012E96 dd effffff51c pushl _test_no
1199 00012E9C fe 08 effffff515 callf $8,_writed
1200 00012EA3 # writes(", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\n");
1201 00012EA3 .data 1
1202 00000f18 * L372:
1203 00000f18 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - THE ACC WAS MODIFIED\12\0"
8506970656420457869742920
2D20544845204143432057415
3204D4F4449464945440A00
1204 00000f49 * .text
1205 00012EA3 dd 8f00000f18 pushl $L372
1206 00012EA9 fe 08 effffff508 callf $8,_writes
1207 00012EB0 # print_cmpf_data();
1208 00012EB0 fe 04 ef000000a1 callf $4,_print_cmpf_data
1209 00012EB7 # writes(", data index = ");
1210 00012EB7 .data 1
1211 00000f49 * L373:
1212 00000f49 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
1213 00000f5a * .text
1214 00012EB7 dd 8f00000f49 pushl $L373
1215 00012EBD fe 08 effffff4f4 callf $8,_writes
1216 00012EC4 # writed( index );
1217 00012EC4 dd effffff4ee pushl _index
1218 00012ECA fe 08 effffff4e7 callf $8,_writed
1219 00012ED1 # writec('\n');
1220 00012ED1 dd 0a pushl $10
1221 00012ED3 fe 08 effffff4de callf $8,_writec
1222 00012EDA # writes(" final Acc = ");
1223 00012EDA .data 1
1224 00000f5a * L374:
1225 00000f5a * 202066696E616C20416363203 .ascii " final Acc = \0"
D2000
1226 00000f69 * .text
1227 00012EDA dd 8f00000f5a pushl $L374
1228 00012EE0 fe 08 effffff4d1 callf $8,_writes
1229 00012EE7 # write32h( sgl_st_acc );
1230 00012EE7 dd effffff4cb pushl _sgl_st_acc
1231 00012EED fe 08 effffff4c4 callf $8,_write32h
1232 00012EF4 # writes(", Acc expected = ");
1233 00012EF4 .data 1
1234 00000f69 * L375:
1235 00000f69 * 2C20204163632065787065637 .ascii ", Acc expected = \0"
46564203D2000
1236 00000f7c * .text
1237 00012EF4 dd 8f00000f69 pushl $L375
1238 00012EFA fe 08 effffff4b7 callf $8,_writes
1239 00012F01 # write32h( sgl_expected );
1240 00012F01 dd effffff4b1 pushl _sgl_expected
1241 00012F07 fe 08 effffff4aa callf $8,_write32h
1242 00012F0E # writec('\n');
1243 00012F0E dd 0a pushl $10
1244 00012F10 fe 08 effffff4a1 callf $8,_writec
1245 00012F17 # }
1246 00012F17 # if ( halt_flg )
1247 00012F17 L368:
1248 00012F17 5d effffff49b tstl _halt_flg
1249 00012F1D 31 09 jeql L376
1250 00012F1F # cmpf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1251 00012F1F dd 01 pushl $1
1252 00012F21 fe 08 ef0000006c callf $8,_cmpf_er_halt
1253 00012F28 # if ( loop_on_err ) {
1254 00012F28 L376:
1255 00012F28 5d effffff48a tstl _loop_on_err
1256 00012F2E 31 0a jeql L377
1257 00012F30 # force_loop = TRUE; /* set the force loop flag */
1258 00012F30 0d 01 effffff481 movl $1,_force_loop
1259 00012F37 # asm("brw _cmpf_6_lp1"); /* and loop on the error */
1260 00012F37 13 fee6 brw _cmpf_6_lp1
1261 00012F3A # } /* end of loop on error */
1262 00012F3A # } /* end of compare error */
1263 00012F3A L377:
1264 00012F3A # } while( index++ < max_cmpf_1_index); /* end of data loop */
1265 00012F3A L367:
1266 00012F3A L362:
1267 00012F3A 0d effffff478 50 movl _index,r0
1268 00012F41 6d effffff471 incl _index
1269 00012F47 1d 50 effffff46a cmpl r0,_max_cmpf_1_index
1270 00012F4E 81 03 13 fe87 jlss L363
1271 00012F53 L361:
1272 00012F53 # } /* end of subtest 6 */
1273 00012F53 40 ret#2
1274 00012F54 .set L357,0x0
1275 00012F54 L359:
1276 00012F54 13 fe70 jbr L360
1277 00012F57 .data
1278 00000c8c * .text
1279 00012F57 00 .align 1
1280 00012F58 .globl _print_cmpf_data
1281 00012F58 _print_cmpf_data:
1282 00012F58 0000 .word L378
1283 00012F5A #
1284 00012F5A #
1285 00012F5A #
1286 00012F5A # /**************************************************************************
1287 00012F5A # *
1288 00012F5A # * PRINT THE DATA AND STORE RESULTS
1289 00012F5A # *
1290 00012F5A # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1291 00012F5A # * operand = xxxxxxxx, expected = xxxxxxxx
1292 00012F5A # **************************************************************************/
1293 00012F5A # print_cmpf_data()
1294 00012F5A # {
1295 00012F5A 11 35 jbr L380
1296 00012F5C L381:
1297 00012F5C # writes("initial Acc = ");
1298 00012F5C .data 1
1299 00000f7c * L382:
1300 00000f7c * 696E697469616C20416363203 .ascii "initial Acc = \0"
D2000
1301 00000f8b * .text
1302 00012F5C dd 8f00000f7c pushl $L382
1303 00012F62 fe 08 effffff44f callf $8,_writes
1304 00012F69 # write32h( sgl_value_1 );
1305 00012F69 dd effffff449 pushl _sgl_value_1
1306 00012F6F fe 08 effffff442 callf $8,_write32h
1307 00012F76 # writes(", operand = ");
1308 00012F76 .data 1
1309 00000f8b * L383:
1310 00000f8b * 2C2020206F706572616E64203 .ascii ", operand = \0"
D2000
1311 00000f9a * .text
1312 00012F76 dd 8f00000f8b pushl $L383
1313 00012F7C fe 08 effffff435 callf $8,_writes
1314 00012F83 # write32h( sgl_value_2 );
1315 00012F83 dd effffff42f pushl _sgl_value_2
1316 00012F89 fe 08 effffff428 callf $8,_write32h
1317 00012F90 # }
1318 00012F90 40 ret#2
1319 00012F91 .set L378,0x0
1320 00012F91 L380:
1321 00012F91 11 c9 jbr L381
1322 00012F93 .data
1323 00000c8c * .text
1324 00012F93 00 .align 1
1325 00012F94 .globl _cmpf_er_halt
1326 00012F94 _cmpf_er_halt:
1327 00012F94 0000 .word L384
1328 00012F96 #
1329 00012F96 #
1330 00012F96 #
1331 00012F96 # /**************************************************************************
1332 00012F96 # *
1333 00012F96 # * HALT ON ERROR ROUTINE
1334 00012F96 # *
1335 00012F96 # **************************************************************************/
1336 00012F96 # cmpf_er_halt( halt_code )
1337 00012F96 # int halt_code;
1338 00012F96 # {
1339 00012F96 13 00a8 jbr L386
1340 00012F99 L387:
1341 00012F99 # sgl_dummy1 = halt_code; /* get the error type */
1342 00012F99 0d ad04 effffff417 movl 4(fp),_sgl_dummy1
1343 00012FA1 # asm("movl _test_no,r0"); /* r0 = test number */
1344 00012FA1 0d effffff411 50 movl _test_no,r0
1345 00012FA8 # asm("movl _subtest,r1"); /* r1 = subtest number */
1346 00012FA8 0d effffff40a 51 movl _subtest,r1
1347 00012FAF # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1348 00012FAF 0d effffff403 52 movl _sgl_dummy1,r2
1349 00012FB6 # asm("movl _cycle,r3"); /* r3 = cycle count */
1350 00012FB6 0d effffff3fc 53 movl _cycle,r3
1351 00012FBD # asm("movl _sgl_value_1,r4"); /* r4 = initial acc */
1352 00012FBD 0d effffff3f5 54 movl _sgl_value_1,r4
1353 00012FC4 # asm("movl _sgl_value_2,r5"); /* r5 = data compared */
1354 00012FC4 0d effffff3ee 55 movl _sgl_value_2,r5
1355 00012FCB # asm("movl _psl_val,r6"); /* r6 = final PSL */
1356 00012FCB 0d effffff3e7 56 movl _psl_val,r6
1357 00012FD2 # if( halt_code == BAD_ACC_HLT ) {
1358 00012FD2 1d ad04 01 cmpl 4(fp),$1
1359 00012FD6 21 10 jneq L388
1360 00012FD8 # asm("movl _sgl_st_acc,r7"); /* r7 = actual value */
1361 00012FD8 0d effffff3da 57 movl _sgl_st_acc,r7
1362 00012FDF # asm("movl _sgl_expected,r8"); /* r8 = expected value */
1363 00012FDF 0d effffff3d3 58 movl _sgl_expected,r8
1364 00012FE6 # } else
1365 00012FE6 11 57 jbr L389
1366 00012FE8 L388:
1367 00012FE8 # if( halt_code == BAD_REG_HLT ) {
1368 00012FE8 1d ad04 02 cmpl 4(fp),$2
1369 00012FEC 21 3d jneq L390
1370 00012FEE # sgl_dummy1 = load_regs[index2];
1371 00012FEE 0d effffff3c4 50 movl _index2,r0
1372 00012FF5 0d 40effffff3bc movl _load_regs[r0],_sgl_dummy1
effffff3b7
1373 00013001 # sgl_dummy2 = store_regs[index2];
1374 00013001 0d effffff3b1 50 movl _index2,r0
1375 00013008 0d 40effffff3a9 movl _store_regs[r0],_sgl_dummy2
effffff3a4
1376 00013014 # asm("movl _index2,r7"); /* r7 = bad register # */
1377 00013014 0d effffff39e 57 movl _index2,r7
1378 0001301B # asm("movl _sgl_dummy2,r8"); /* r8 = actual value */
1379 0001301B 0d effffff397 58 movl _sgl_dummy2,r8
1380 00013022 # asm("movl _sgl_dummy1,r9"); /* r9 = expected value */
1381 00013022 0d effffff390 59 movl _sgl_dummy1,r9
1382 00013029 # } else
1383 00013029 11 14 jbr L391
1384 0001302B L390:
1385 0001302B # if( halt_code == BAD_PSL_HLT ) {
1386 0001302B 1d ad04 03 cmpl 4(fp),$3
1387 0001302F 21 0e jneq L392
1388 00013031 # asm("movl _exp_psl,r7"); /* r7 = expected PSL */
1389 00013031 0d effffff381 57 movl _exp_psl,r7
1390 00013038 # asm("movl _index,r7"); /* r8 = data index */
1391 00013038 0d effffff37a 57 movl _index,r7
1392 0001303F # };
1393 0001303F L392:
1394 0001303F L391:
1395 0001303F L389:
1396 0001303F # asm("halt"); /* HALT ... */
1397 0001303F 00 halt
1398 00013040 # }
1399 00013040 40 ret#2
1400 00013041 .set L384,0x0
1401 00013041 L386:
1402 00013041 13 ff55 jbr L387
1403 00000c8c * .data
1403 00000c8c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.