![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subf.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 subf.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 00000d28 * .text
4 00000000 .align 1
5 00000000 .globl _subf
6 00000000 _subf:
7 0000E0A4 0000 .word L215
8 0000E0A6 #
9 0000E0A6 # #include "fpp_defs.h"
10 0000E0A6 #
11 0000E0A6 #
12 0000E0A6 # /*****************************************************************************
13 0000E0A6 # *
14 0000E0A6 # * SUBF - SINGLE PRECISION FLOATING POINT ADD TEST
15 0000E0A6 # *
16 0000E0A6 # *****************************************************************************/
17 0000E0A6 # subf()
18 0000E0A6 # {
19 0000E0A6 11 64 jbr L217
20 0000E0A8 L218:
21 0000E0A8 # asm(".globl _subf_t");
22 0000E0A8 .globl _subf_t
23 0000E0A8 # asm("_subf_t:"); /* entry address */
24 0000E0A8 _subf_t:
25 0000E0A8 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26 0000E0A8 1d effffffff6 01 cmpl _cycle,$1
27 0000E0AF 21 15 jneq L219
28 0000E0B1 5d efffffffed tstl _prt_hdrs
29 0000E0B7 31 0d jeql L219
30 0000E0B9 # writes(" SUBF");
31 0000E0B9 .data 1
32 00000d28 * L221:
33 00000d28 * 205355424600 .ascii " SUBF\0"
34 00000d2e * .text
35 0000E0B9 dd 8f00000d28 pushl $L221
36 0000E0BF fe 08 efffffffde callf $8,_writes
37 0000E0C6 # subf_1(); /* subract through a register */
38 0000E0C6 L219:
39 0000E0C6 fe 04 ef00000041 callf $4,_subf_1
40 0000E0CD # subf_2(); /* subract through the cache */
41 0000E0CD fe 04 ef00000160 callf $4,_subf_2
42 0000E0D4 # subf_3(); /* wait 3 NOPs */
43 0000E0D4 fe 04 ef00000279 callf $4,_subf_3
44 0000E0DB # subf_4(); /* wait 2 NOPs */
45 0000E0DB fe 04 ef00000396 callf $4,_subf_4
46 0000E0E2 # subf_5(); /* wait 1 NOP before storing */
47 0000E0E2 fe 04 ef000004b3 callf $4,_subf_5
48 0000E0E9 # subf_6(); /* register stability test */
49 0000E0E9 fe 04 ef000005ce callf $4,_subf_6
50 0000E0F0 # subf_7(); /* PSL stability test */
51 0000E0F0 fe 04 ef00000777 callf $4,_subf_7
52 0000E0F7 # subf_8(); /* pipelined entry test */
53 0000E0F7 fe 04 ef0000092a callf $4,_subf_8
54 0000E0FE # subf_9(); /* pipelined exit test */
55 0000E0FE fe 04 ef00000a49 callf $4,_subf_9
56 0000E105 # asm("jmp *return"); /* return to the test monitor */
57 0000E105 71 ffffffff99 jmp *return
58 0000E10B # }
59 0000E10B 40 ret#2
60 0000E10C .set L215,0x0
61 0000E10C L217:
62 0000E10C 11 9a jbr L218
63 0000E10E .data
64 00000d28 * .text
65 0000E10E .align 1
66 0000E10E .globl _subf_1
67 0000E10E _subf_1:
68 0000E10E 0000 .word L231
69 0000E110 #
70 0000E110 #
71 0000E110 #
72 0000E110 # /************************************************************************
73 0000E110 # *
74 0000E110 # * SUBTEST 1 - subract through a register
75 0000E110 # *
76 0000E110 # ************************************************************************/
77 0000E110 # subf_1()
78 0000E110 # {
79 0000E110 13 011e jbr L233
80 0000E113 L234:
81 0000E113 # force_loop = FALSE;
82 0000E113 4d efffffff8b clrl _force_loop
83 0000E119 # subtest = 1;
84 0000E119 0d 01 efffffff84 movl $1,_subtest
85 0000E120 # for( index = 0; index < max_subf_1_index; index++ ) {
86 0000E120 4d efffffff7e clrl _index
87 0000E126 L237:
88 0000E126 1d efffffff78 efffffff73 cmpl _index,_max_subf_1_index
89 0000E131 91 03 13 00fa jgeq L236
90 0000E136 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
91 0000E136 5c 0c efffffff67 50 mull3 $12,_index,r0
92 0000E13E 0d e000000000 efffffff5b movl _subf_1_data(r0),_sgl_ld_acc
93 0000E149 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
94 0000E149 5c 0c efffffff54 50 mull3 $12,_index,r0
95 0000E151 0d e000000004 efffffff48 movl _subf_1_data+4(r0),_sgl_value_1
96 0000E15C # sgl_expected = subf_1_data[index].exp; /* get expected result */
97 0000E15C 5c 0c efffffff41 50 mull3 $12,_index,r0
98 0000E164 0d e000000008 efffffff35 movl _subf_1_data+8(r0),_sgl_expected
99 0000E16F # /*
100 0000E16F # * If LOOP ON ERROR is set, this is the loop for this subtest.
101 0000E16F # * The force loop flag is set after the first error.
102 0000E16F # */
103 0000E16F # asm("_subf_1_lp1:");
104 0000E16F _subf_1_lp1:
105 0000E16F # asm("movl _sgl_ld_acc,r3"); /* move the 1st data to r3 */
106 0000E16F 0d efffffff2f 53 movl _sgl_ld_acc,r3
107 0000E176 # asm("movl _sgl_value_1,r4"); /* move the 2nd data to r4 */
108 0000E176 0d efffffff28 54 movl _sgl_value_1,r4
109 0000E17D # asm("ldf r3"); /* load the 1st operand */
110 0000E17D 06 53 ldf r3
111 0000E17F # asm("subf r4"); /* subract the 2nd operand */
112 0000E17F d6 54 subf r4
113 0000E181 # asm("stf _sgl_st_acc"); /* store the result */
114 0000E181 26 efffffff1d stf _sgl_st_acc
115 0000E187 # if( force_loop )
116 0000E187 5d efffffff17 tstl _force_loop
117 0000E18D 31 02 jeql L238
118 0000E18F # asm("brb _subf_1_lp1");; /* loop on the error */
119 0000E18F 11 de brb _subf_1_lp1
120 0000E191 L238:
121 0000E191 # /*
122 0000E191 # * end error loop - test the results
123 0000E191 # */
124 0000E191 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
125 0000E191 1d efffffff0d efffffff08 cmpl _sgl_st_acc,_sgl_expected
126 0000E19C 21 03 13 0086 jeql L239
127 0000E1A1 # errcnt++; /* bump the error count */
128 0000E1A1 6d effffffefd incl _errcnt
129 0000E1A7 # if( prt_error ) {
130 0000E1A7 5d effffffef7 tstl _prt_error
131 0000E1AD 31 55 jeql L240
132 0000E1AF # writes(" \n"); /* start a new print line */
133 0000E1AF .data 1
134 00000d2e * L241:
135 00000d2e * 200A00 .ascii " \12\0"
136 00000d31 * .text
137 0000E1AF dd 8f00000d2e pushl $L241
138 0000E1B5 fe 08 effffffee8 callf $8,_writes
139 0000E1BC # writes("cycle: ");
140 0000E1BC .data 1
141 00000d31 * L242:
142 00000d31 * 6379636C653A2000 .ascii "cycle: \0"
143 00000d39 * .text
144 0000E1BC dd 8f00000d31 pushl $L242
145 0000E1C2 fe 08 effffffedb callf $8,_writes
146 0000E1C9 # writed( cycle );
147 0000E1C9 dd effffffed5 pushl _cycle
148 0000E1CF fe 08 effffffece callf $8,_writed
149 0000E1D6 # writes(" SUBF test ");
150 0000E1D6 .data 1
151 00000d39 * L244:
152 00000d39 * 2020535542462074657374200 .ascii " SUBF test \0"
0
153 00000d46 * .text
154 0000E1D6 dd 8f00000d39 pushl $L244
155 0000E1DC fe 08 effffffec1 callf $8,_writes
156 0000E1E3 # writed( test_no );
157 0000E1E3 dd effffffebb pushl _test_no
158 0000E1E9 fe 08 effffffeb4 callf $8,_writed
159 0000E1F0 # writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n");
160 0000E1F0 .data 1
161 00000d46 * L245:
162 00000d46 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL ACC\12\0"
85265672E204461746129202D
204241442046494E414C20414
3430A00
163 00000d6f * .text
164 0000E1F0 dd 8f00000d46 pushl $L245
165 0000E1F6 fe 08 effffffea7 callf $8,_writes
166 0000E1FD # print_subf_data();
167 0000E1FD fe 04 ef00000a70 callf $4,_print_subf_data
168 0000E204 # }
169 0000E204 # if( halt_flg )
170 0000E204 L240:
171 0000E204 5d effffffe9a tstl _halt_flg
172 0000E20A 31 09 jeql L247
173 0000E20C # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
174 0000E20C dd 01 pushl $1
175 0000E20E fe 08 ef00000afd callf $8,_subf_er_halt
176 0000E215 # if( loop_on_err ) {
177 0000E215 L247:
178 0000E215 5d effffffe89 tstl _loop_on_err
179 0000E21B 31 0a jeql L249
180 0000E21D # force_loop = TRUE; /* set the force loop flag */
181 0000E21D 0d 01 effffffe80 movl $1,_force_loop
182 0000E224 # asm("brw _subf_1_lp1");; /* and loop on the error */
183 0000E224 13 ff48 brw _subf_1_lp1
184 0000E227 # } /* end of loop on error */
185 0000E227 # } /* end of compare error */
186 0000E227 L249:
187 0000E227 # } /* end of WHILE loop */
188 0000E227 L239:
189 0000E227 L235:
190 0000E227 6d effffffe77 incl _index
191 0000E22D 13 fef6 jbr L237
192 0000E230 L236:
193 0000E230 # } /* end of subtest 1 */
194 0000E230 40 ret#2
195 0000E231 .set L231,0x0
196 0000E231 L233:
197 0000E231 13 fedf jbr L234
198 0000E234 .data
199 00000d28 * .text
200 0000E234 .align 1
201 0000E234 .globl _subf_2
202 0000E234 _subf_2:
203 0000E234 0000 .word L250
204 0000E236 #
205 0000E236 #
206 0000E236 #
207 0000E236 # /************************************************************************
208 0000E236 # *
209 0000E236 # * SUBTEST 2 - subract through memory
210 0000E236 # *
211 0000E236 # ************************************************************************/
212 0000E236 # subf_2()
213 0000E236 # {
214 0000E236 13 0118 jbr L252
215 0000E239 L253:
216 0000E239 # force_loop = FALSE;
217 0000E239 4d effffffe65 clrl _force_loop
218 0000E23F # subtest = 2;
219 0000E23F 0d 02 effffffe5e movl $2,_subtest
220 0000E246 # for( index = 0; index < max_subf_1_index; index++ ) {
221 0000E246 4d effffffe58 clrl _index
222 0000E24C L256:
223 0000E24C 1d effffffe52 effffffe4d cmpl _index,_max_subf_1_index
224 0000E257 91 03 13 00f4 jgeq L255
225 0000E25C # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
226 0000E25C 5c 0c effffffe41 50 mull3 $12,_index,r0
227 0000E264 0d e000000000 effffffe35 movl _subf_1_data(r0),_sgl_ld_acc
228 0000E26F # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
229 0000E26F 5c 0c effffffe2e 50 mull3 $12,_index,r0
230 0000E277 0d e000000004 effffffe22 movl _subf_1_data+4(r0),_sgl_value_1
231 0000E282 # sgl_expected = subf_1_data[index].exp; /* get expected result */
232 0000E282 5c 0c effffffe1b 50 mull3 $12,_index,r0
233 0000E28A 0d e000000008 effffffe0f movl _subf_1_data+8(r0),_sgl_expected
234 0000E295 # /*
235 0000E295 # * If LOOP ON ERROR is set, this is the loop for this subtest.
236 0000E295 # * The force loop flag is set after the first error.
237 0000E295 # */
238 0000E295 # asm("_subf_2_lp1:");
239 0000E295 _subf_2_lp1:
240 0000E295 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
241 0000E295 06 effffffe09 ldf _sgl_ld_acc
242 0000E29B # asm("subf _sgl_value_1"); /* sub the 2nd operand */
243 0000E29B d6 effffffe03 subf _sgl_value_1
244 0000E2A1 # asm("stf _sgl_st_acc"); /* store the result */
245 0000E2A1 26 effffffdfd stf _sgl_st_acc
246 0000E2A7 # if( force_loop )
247 0000E2A7 5d effffffdf7 tstl _force_loop
248 0000E2AD 31 02 jeql L257
249 0000E2AF # asm("brb _subf_2_lp1");; /* loop on the error */
250 0000E2AF 11 e4 brb _subf_2_lp1
251 0000E2B1 L257:
252 0000E2B1 # /*
253 0000E2B1 # * end error loop - test the results
254 0000E2B1 # */
255 0000E2B1 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
256 0000E2B1 1d effffffded effffffde8 cmpl _sgl_st_acc,_sgl_expected
257 0000E2BC 21 03 13 0086 jeql L258
258 0000E2C1 # errcnt++; /* bump the error count */
259 0000E2C1 6d effffffddd incl _errcnt
260 0000E2C7 # if( prt_error ) {
261 0000E2C7 5d effffffdd7 tstl _prt_error
262 0000E2CD 31 55 jeql L259
263 0000E2CF # writes(" \n"); /* start a new print line */
264 0000E2CF .data 1
265 00000d6f * L260:
266 00000d6f * 200A00 .ascii " \12\0"
267 00000d72 * .text
268 0000E2CF dd 8f00000d6f pushl $L260
269 0000E2D5 fe 08 effffffdc8 callf $8,_writes
270 0000E2DC # writes("cycle: ");
271 0000E2DC .data 1
272 00000d72 * L261:
273 00000d72 * 6379636C653A2000 .ascii "cycle: \0"
274 00000d7a * .text
275 0000E2DC dd 8f00000d72 pushl $L261
276 0000E2E2 fe 08 effffffdbb callf $8,_writes
277 0000E2E9 # writed( cycle );
278 0000E2E9 dd effffffdb5 pushl _cycle
279 0000E2EF fe 08 effffffdae callf $8,_writed
280 0000E2F6 # writes(" SUBF test ");
281 0000E2F6 .data 1
282 00000d7a * L262:
283 00000d7a * 2020535542462074657374200 .ascii " SUBF test \0"
0
284 00000d87 * .text
285 0000E2F6 dd 8f00000d7a pushl $L262
286 0000E2FC fe 08 effffffda1 callf $8,_writes
287 0000E303 # writed( test_no );
288 0000E303 dd effffffd9b pushl _test_no
289 0000E309 fe 08 effffffd94 callf $8,_writed
290 0000E310 # writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n");
291 0000E310 .data 1
292 00000d87 * L263:
293 00000d87 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL ACC\12\0"
8436163686520446174612920
2D204241442046494E414C204
143430A00
294 00000db1 * .text
295 0000E310 dd 8f00000d87 pushl $L263
296 0000E316 fe 08 effffffd87 callf $8,_writes
297 0000E31D # print_subf_data();
298 0000E31D fe 04 ef00000950 callf $4,_print_subf_data
299 0000E324 # }
300 0000E324 # if( halt_flg )
301 0000E324 L259:
302 0000E324 5d effffffd7a tstl _halt_flg
303 0000E32A 31 09 jeql L264
304 0000E32C # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
305 0000E32C dd 01 pushl $1
306 0000E32E fe 08 ef000009dd callf $8,_subf_er_halt
307 0000E335 # if( loop_on_err ) {
308 0000E335 L264:
309 0000E335 5d effffffd69 tstl _loop_on_err
310 0000E33B 31 0a jeql L265
311 0000E33D # force_loop = TRUE; /* set the force loop flag */
312 0000E33D 0d 01 effffffd60 movl $1,_force_loop
313 0000E344 # asm("brw _subf_2_lp1");; /* and loop on the error */
314 0000E344 13 ff4e brw _subf_2_lp1
315 0000E347 # } /* end of loop on error */
316 0000E347 # } /* end of compare error */
317 0000E347 L265:
318 0000E347 # } /* end of WHILE loop */
319 0000E347 L258:
320 0000E347 L254:
321 0000E347 6d effffffd57 incl _index
322 0000E34D 13 fefc jbr L256
323 0000E350 L255:
324 0000E350 # } /* end of subtest 2 */
325 0000E350 40 ret#2
326 0000E351 .set L250,0x0
327 0000E351 L252:
328 0000E351 13 fee5 jbr L253
329 0000E354 .data
330 00000d28 * .text
331 0000E354 .align 1
332 0000E354 .globl _subf_3
333 0000E354 _subf_3:
334 0000E354 0000 .word L266
335 0000E356 #
336 0000E356 #
337 0000E356 #
338 0000E356 # /************************************************************************
339 0000E356 # *
340 0000E356 # * SUBTEST 3 - Wait 3 NOPs before storing the results
341 0000E356 # *
342 0000E356 # ************************************************************************/
343 0000E356 # subf_3()
344 0000E356 # {
345 0000E356 13 011c jbr L268
346 0000E359 L269:
347 0000E359 # force_loop = FALSE;
348 0000E359 4d effffffd45 clrl _force_loop
349 0000E35F # subtest = 3;
350 0000E35F 0d 03 effffffd3e movl $3,_subtest
351 0000E366 # for( index = 0; index < max_subf_1_index; index++ ) {
352 0000E366 4d effffffd38 clrl _index
353 0000E36C L272:
354 0000E36C 1d effffffd32 effffffd2d cmpl _index,_max_subf_1_index
355 0000E377 91 03 13 00f8 jgeq L271
356 0000E37C # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
357 0000E37C 5c 0c effffffd21 50 mull3 $12,_index,r0
358 0000E384 0d e000000000 effffffd15 movl _subf_1_data(r0),_sgl_ld_acc
359 0000E38F # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
360 0000E38F 5c 0c effffffd0e 50 mull3 $12,_index,r0
361 0000E397 0d e000000004 effffffd02 movl _subf_1_data+4(r0),_sgl_value_1
362 0000E3A2 # sgl_expected = subf_1_data[index].exp; /* get expected result */
363 0000E3A2 5c 0c effffffcfb 50 mull3 $12,_index,r0
364 0000E3AA 0d e000000008 effffffcef movl _subf_1_data+8(r0),_sgl_expected
365 0000E3B5 # /*
366 0000E3B5 # * If LOOP ON ERROR is set, this is the loop for this subtest.
367 0000E3B5 # * The force loop flag is set after the first error.
368 0000E3B5 # */
369 0000E3B5 # asm("_subf_3_lp1:");
370 0000E3B5 _subf_3_lp1:
371 0000E3B5 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
372 0000E3B5 06 effffffce9 ldf _sgl_ld_acc
373 0000E3BB # asm("nop"); /* delay */
374 0000E3BB 10 nop
375 0000E3BC # asm("subf _sgl_value_1"); /* sub the 2nd operand */
376 0000E3BC d6 effffffce2 subf _sgl_value_1
377 0000E3C2 # asm("nop"); /* delay before ... */
378 0000E3C2 10 nop
379 0000E3C3 # asm("nop");
380 0000E3C3 10 nop
381 0000E3C4 # asm("nop"); /* ... storing the result */
382 0000E3C4 10 nop
383 0000E3C5 # asm("stf _sgl_st_acc"); /* store the result */
384 0000E3C5 26 effffffcd9 stf _sgl_st_acc
385 0000E3CB # if( force_loop )
386 0000E3CB 5d effffffcd3 tstl _force_loop
387 0000E3D1 31 02 jeql L273
388 0000E3D3 # asm("brb _subf_3_lp1");; /* loop on the error */
389 0000E3D3 11 e0 brb _subf_3_lp1
390 0000E3D5 L273:
391 0000E3D5 # /*
392 0000E3D5 # * end error loop - test the results
393 0000E3D5 # */
394 0000E3D5 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
395 0000E3D5 1d effffffcc9 effffffcc4 cmpl _sgl_st_acc,_sgl_expected
396 0000E3E0 21 03 13 0086 jeql L274
397 0000E3E5 # errcnt++; /* bump the error count */
398 0000E3E5 6d effffffcb9 incl _errcnt
399 0000E3EB # if( prt_error ) {
400 0000E3EB 5d effffffcb3 tstl _prt_error
401 0000E3F1 31 55 jeql L275
402 0000E3F3 # writes(" \n"); /* start a new print line */
403 0000E3F3 .data 1
404 00000db1 * L276:
405 00000db1 * 200A00 .ascii " \12\0"
406 00000db4 * .text
407 0000E3F3 dd 8f00000db1 pushl $L276
408 0000E3F9 fe 08 effffffca4 callf $8,_writes
409 0000E400 # writes("cycle: ");
410 0000E400 .data 1
411 00000db4 * L277:
412 00000db4 * 6379636C653A2000 .ascii "cycle: \0"
413 00000dbc * .text
414 0000E400 dd 8f00000db4 pushl $L277
415 0000E406 fe 08 effffffc97 callf $8,_writes
416 0000E40D # writed( cycle );
417 0000E40D dd effffffc91 pushl _cycle
418 0000E413 fe 08 effffffc8a callf $8,_writed
419 0000E41A # writes(" SUBF test ");
420 0000E41A .data 1
421 00000dbc * L278:
422 00000dbc * 2020535542462074657374200 .ascii " SUBF test \0"
0
423 00000dc9 * .text
424 0000E41A dd 8f00000dbc pushl $L278
425 0000E420 fe 08 effffffc7d callf $8,_writes
426 0000E427 # writed( test_no );
427 0000E427 dd effffffc77 pushl _test_no
428 0000E42D fe 08 effffffc70 callf $8,_writed
429 0000E434 # writes(", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\n");
430 0000E434 .data 1
431 00000dc9 * L279:
432 00000dc9 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\12\0"
843616368652044617461202D
2033204E4F505329202D20424
1442046494E414C204143430A
00
433 00000dfc * .text
434 0000E434 dd 8f00000dc9 pushl $L279
435 0000E43A fe 08 effffffc63 callf $8,_writes
436 0000E441 # print_subf_data();
437 0000E441 fe 04 ef0000082c callf $4,_print_subf_data
438 0000E448 # }
439 0000E448 # if( halt_flg )
440 0000E448 L275:
441 0000E448 5d effffffc56 tstl _halt_flg
442 0000E44E 31 09 jeql L280
443 0000E450 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
444 0000E450 dd 01 pushl $1
445 0000E452 fe 08 ef000008b9 callf $8,_subf_er_halt
446 0000E459 # if( loop_on_err ) {
447 0000E459 L280:
448 0000E459 5d effffffc45 tstl _loop_on_err
449 0000E45F 31 0a jeql L281
450 0000E461 # force_loop = TRUE; /* set the force loop flag */
451 0000E461 0d 01 effffffc3c movl $1,_force_loop
452 0000E468 # asm("brw _subf_3_lp1");; /* and loop on the error */
453 0000E468 13 ff4a brw _subf_3_lp1
454 0000E46B # } /* end of loop on error */
455 0000E46B # } /* end of compare error */
456 0000E46B L281:
457 0000E46B # } /* end of WHILE loop */
458 0000E46B L274:
459 0000E46B L270:
460 0000E46B 6d effffffc33 incl _index
461 0000E471 13 fef8 jbr L272
462 0000E474 L271:
463 0000E474 # } /* end of subtest 3 */
464 0000E474 40 ret#2
465 0000E475 .set L266,0x0
466 0000E475 L268:
467 0000E475 13 fee1 jbr L269
468 0000E478 .data
469 00000d28 * .text
470 0000E478 .align 1
471 0000E478 .globl _subf_4
472 0000E478 _subf_4:
473 0000E478 0000 .word L282
474 0000E47A #
475 0000E47A #
476 0000E47A #
477 0000E47A # /************************************************************************
478 0000E47A # *
479 0000E47A # * SUBTEST 4 - Wait 2 NOPs before storing the results
480 0000E47A # *
481 0000E47A # ************************************************************************/
482 0000E47A # subf_4()
483 0000E47A # {
484 0000E47A 13 011b jbr L284
485 0000E47D L285:
486 0000E47D # force_loop = FALSE;
487 0000E47D 4d effffffc21 clrl _force_loop
488 0000E483 # subtest = 4;
489 0000E483 0d 04 effffffc1a movl $4,_subtest
490 0000E48A # for( index = 0; index < max_subf_1_index; index++ ) {
491 0000E48A 4d effffffc14 clrl _index
492 0000E490 L288:
493 0000E490 1d effffffc0e effffffc09 cmpl _index,_max_subf_1_index
494 0000E49B 91 03 13 00f7 jgeq L287
495 0000E4A0 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
496 0000E4A0 5c 0c effffffbfd 50 mull3 $12,_index,r0
497 0000E4A8 0d e000000000 effffffbf1 movl _subf_1_data(r0),_sgl_ld_acc
498 0000E4B3 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
499 0000E4B3 5c 0c effffffbea 50 mull3 $12,_index,r0
500 0000E4BB 0d e000000004 effffffbde movl _subf_1_data+4(r0),_sgl_value_1
501 0000E4C6 # sgl_expected = subf_1_data[index].exp; /* get expected result */
502 0000E4C6 5c 0c effffffbd7 50 mull3 $12,_index,r0
503 0000E4CE 0d e000000008 effffffbcb movl _subf_1_data+8(r0),_sgl_expected
504 0000E4D9 # /*
505 0000E4D9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
506 0000E4D9 # * The force loop flag is set after the first error.
507 0000E4D9 # */
508 0000E4D9 # asm("_subf_4_lp1:");
509 0000E4D9 _subf_4_lp1:
510 0000E4D9 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
511 0000E4D9 06 effffffbc5 ldf _sgl_ld_acc
512 0000E4DF # asm("nop"); /* delay */
513 0000E4DF 10 nop
514 0000E4E0 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
515 0000E4E0 d6 effffffbbe subf _sgl_value_1
516 0000E4E6 # asm("nop"); /* delay before ... */
517 0000E4E6 10 nop
518 0000E4E7 # asm("nop"); /* ... storing the result */
519 0000E4E7 10 nop
520 0000E4E8 # asm("stf _sgl_st_acc"); /* store the result */
521 0000E4E8 26 effffffbb6 stf _sgl_st_acc
522 0000E4EE # if( force_loop )
523 0000E4EE 5d effffffbb0 tstl _force_loop
524 0000E4F4 31 02 jeql L289
525 0000E4F6 # asm("brb _subf_4_lp1");; /* loop on the error */
526 0000E4F6 11 e1 brb _subf_4_lp1
527 0000E4F8 L289:
528 0000E4F8 # /*
529 0000E4F8 # * end error loop - test the results
530 0000E4F8 # */
531 0000E4F8 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
532 0000E4F8 1d effffffba6 effffffba1 cmpl _sgl_st_acc,_sgl_expected
533 0000E503 21 03 13 0086 jeql L290
534 0000E508 # errcnt++; /* bump the error count */
535 0000E508 6d effffffb96 incl _errcnt
536 0000E50E # if( prt_error ) {
537 0000E50E 5d effffffb90 tstl _prt_error
538 0000E514 31 55 jeql L291
539 0000E516 # writes(" \n"); /* start a new print line */
540 0000E516 .data 1
541 00000dfc * L292:
542 00000dfc * 200A00 .ascii " \12\0"
543 00000dff * .text
544 0000E516 dd 8f00000dfc pushl $L292
545 0000E51C fe 08 effffffb81 callf $8,_writes
546 0000E523 # writes("cycle: ");
547 0000E523 .data 1
548 00000dff * L293:
549 00000dff * 6379636C653A2000 .ascii "cycle: \0"
550 00000e07 * .text
551 0000E523 dd 8f00000dff pushl $L293
552 0000E529 fe 08 effffffb74 callf $8,_writes
553 0000E530 # writed( cycle );
554 0000E530 dd effffffb6e pushl _cycle
555 0000E536 fe 08 effffffb67 callf $8,_writed
556 0000E53D # writes(" SUBF test ");
557 0000E53D .data 1
558 00000e07 * L294:
559 00000e07 * 2020535542462074657374200 .ascii " SUBF test \0"
0
560 00000e14 * .text
561 0000E53D dd 8f00000e07 pushl $L294
562 0000E543 fe 08 effffffb5a callf $8,_writes
563 0000E54A # writed( test_no );
564 0000E54A dd effffffb54 pushl _test_no
565 0000E550 fe 08 effffffb4d callf $8,_writed
566 0000E557 # writes(", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\n");
567 0000E557 .data 1
568 00000e14 * L295:
569 00000e14 * 2C20737562746573742034202 .ascii ", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\12\0"
843616368652044617461202D
2032204E4F505329202D20424
1442046494E414C204143430A
00
570 00000e47 * .text
571 0000E557 dd 8f00000e14 pushl $L295
572 0000E55D fe 08 effffffb40 callf $8,_writes
573 0000E564 # print_subf_data();
574 0000E564 fe 04 ef00000709 callf $4,_print_subf_data
575 0000E56B # }
576 0000E56B # if( halt_flg )
577 0000E56B L291:
578 0000E56B 5d effffffb33 tstl _halt_flg
579 0000E571 31 09 jeql L296
580 0000E573 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
581 0000E573 dd 01 pushl $1
582 0000E575 fe 08 ef00000796 callf $8,_subf_er_halt
583 0000E57C # if( loop_on_err ) {
584 0000E57C L296:
585 0000E57C 5d effffffb22 tstl _loop_on_err
586 0000E582 31 0a jeql L297
587 0000E584 # force_loop = TRUE; /* set the force loop flag */
588 0000E584 0d 01 effffffb19 movl $1,_force_loop
589 0000E58B # asm("brw _subf_4_lp1");; /* and loop on the error */
590 0000E58B 13 ff4b brw _subf_4_lp1
591 0000E58E # } /* end of loop on error */
592 0000E58E # } /* end of compare error */
593 0000E58E L297:
594 0000E58E # } /* end of WHILE loop */
595 0000E58E L290:
596 0000E58E L286:
597 0000E58E 6d effffffb10 incl _index
598 0000E594 13 fef9 jbr L288
599 0000E597 L287:
600 0000E597 # } /* end of subtest 4 */
601 0000E597 40 ret#2
602 0000E598 .set L282,0x0
603 0000E598 L284:
604 0000E598 13 fee2 jbr L285
605 0000E59B .data
606 00000d28 * .text
607 0000E59B 00 .align 1
608 0000E59C .globl _subf_5
609 0000E59C _subf_5:
610 0000E59C 0000 .word L298
611 0000E59E #
612 0000E59E #
613 0000E59E #
614 0000E59E # /************************************************************************
615 0000E59E # *
616 0000E59E # * SUBTEST 5 - Wait 1 NOP before storing the results
617 0000E59E # *
618 0000E59E # ************************************************************************/
619 0000E59E # subf_5()
620 0000E59E # {
621 0000E59E 13 011a jbr L300
622 0000E5A1 L301:
623 0000E5A1 # force_loop = FALSE;
624 0000E5A1 4d effffffafd clrl _force_loop
625 0000E5A7 # subtest = 5;
626 0000E5A7 0d 05 effffffaf6 movl $5,_subtest
627 0000E5AE # for( index = 0; index < max_subf_1_index; index++ ) {
628 0000E5AE 4d effffffaf0 clrl _index
629 0000E5B4 L304:
630 0000E5B4 1d effffffaea effffffae5 cmpl _index,_max_subf_1_index
631 0000E5BF 91 03 13 00f6 jgeq L303
632 0000E5C4 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
633 0000E5C4 5c 0c effffffad9 50 mull3 $12,_index,r0
634 0000E5CC 0d e000000000 effffffacd movl _subf_1_data(r0),_sgl_ld_acc
635 0000E5D7 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
636 0000E5D7 5c 0c effffffac6 50 mull3 $12,_index,r0
637 0000E5DF 0d e000000004 effffffaba movl _subf_1_data+4(r0),_sgl_value_1
638 0000E5EA # sgl_expected = subf_1_data[index].exp; /* get expected result */
639 0000E5EA 5c 0c effffffab3 50 mull3 $12,_index,r0
640 0000E5F2 0d e000000008 effffffaa7 movl _subf_1_data+8(r0),_sgl_expected
641 0000E5FD # /*
642 0000E5FD # * If LOOP ON ERROR is set, this is the loop for this subtest.
643 0000E5FD # * The force loop flag is set after the first error.
644 0000E5FD # */
645 0000E5FD # asm("_subf_5_lp1:");
646 0000E5FD _subf_5_lp1:
647 0000E5FD # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
648 0000E5FD 06 effffffaa1 ldf _sgl_ld_acc
649 0000E603 # asm("nop"); /* delay */
650 0000E603 10 nop
651 0000E604 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
652 0000E604 d6 effffffa9a subf _sgl_value_1
653 0000E60A # asm("nop"); /* delay before storing */
654 0000E60A 10 nop
655 0000E60B # asm("stf _sgl_st_acc"); /* store the result */
656 0000E60B 26 effffffa93 stf _sgl_st_acc
657 0000E611 # if( force_loop )
658 0000E611 5d effffffa8d tstl _force_loop
659 0000E617 31 02 jeql L305
660 0000E619 # asm("brb _subf_5_lp1");; /* loop on the error */
661 0000E619 11 e2 brb _subf_5_lp1
662 0000E61B L305:
663 0000E61B # /*
664 0000E61B # * end error loop - test the results
665 0000E61B # */
666 0000E61B # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
667 0000E61B 1d effffffa83 effffffa7e cmpl _sgl_st_acc,_sgl_expected
668 0000E626 21 03 13 0086 jeql L306
669 0000E62B # errcnt++; /* bump the error count */
670 0000E62B 6d effffffa73 incl _errcnt
671 0000E631 # if( prt_error ) {
672 0000E631 5d effffffa6d tstl _prt_error
673 0000E637 31 55 jeql L307
674 0000E639 # writes(" \n"); /* start a new print line */
675 0000E639 .data 1
676 00000e47 * L308:
677 00000e47 * 200A00 .ascii " \12\0"
678 00000e4a * .text
679 0000E639 dd 8f00000e47 pushl $L308
680 0000E63F fe 08 effffffa5e callf $8,_writes
681 0000E646 # writes("cycle: ");
682 0000E646 .data 1
683 00000e4a * L309:
684 00000e4a * 6379636C653A2000 .ascii "cycle: \0"
685 00000e52 * .text
686 0000E646 dd 8f00000e4a pushl $L309
687 0000E64C fe 08 effffffa51 callf $8,_writes
688 0000E653 # writed( cycle );
689 0000E653 dd effffffa4b pushl _cycle
690 0000E659 fe 08 effffffa44 callf $8,_writed
691 0000E660 # writes(" SUBF test ");
692 0000E660 .data 1
693 00000e52 * L310:
694 00000e52 * 2020535542462074657374200 .ascii " SUBF test \0"
0
695 00000e5f * .text
696 0000E660 dd 8f00000e52 pushl $L310
697 0000E666 fe 08 effffffa37 callf $8,_writes
698 0000E66D # writed( test_no );
699 0000E66D dd effffffa31 pushl _test_no
700 0000E673 fe 08 effffffa2a callf $8,_writed
701 0000E67A # writes(", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\n");
702 0000E67A .data 1
703 00000e5f * L311:
704 00000e5f * 2C20737562746573742035202 .ascii ", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\12\0"
843616368652044617461202D
2031204E4F505329202D20424
1442046494E414C204143430A
00
705 00000e92 * .text
706 0000E67A dd 8f00000e5f pushl $L311
707 0000E680 fe 08 effffffa1d callf $8,_writes
708 0000E687 # print_subf_data();
709 0000E687 fe 04 ef000005e6 callf $4,_print_subf_data
710 0000E68E # }
711 0000E68E # if( halt_flg )
712 0000E68E L307:
713 0000E68E 5d effffffa10 tstl _halt_flg
714 0000E694 31 09 jeql L312
715 0000E696 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
716 0000E696 dd 01 pushl $1
717 0000E698 fe 08 ef00000673 callf $8,_subf_er_halt
718 0000E69F # if( loop_on_err ) {
719 0000E69F L312:
720 0000E69F 5d effffff9ff tstl _loop_on_err
721 0000E6A5 31 0a jeql L313
722 0000E6A7 # force_loop = TRUE; /* set the force loop flag */
723 0000E6A7 0d 01 effffff9f6 movl $1,_force_loop
724 0000E6AE # asm("brw _subf_5_lp1");; /* and loop on the error */
725 0000E6AE 13 ff4c brw _subf_5_lp1
726 0000E6B1 # } /* end of loop on error */
727 0000E6B1 # } /* end of compare error */
728 0000E6B1 L313:
729 0000E6B1 # } /* end of WHILE loop */
730 0000E6B1 L306:
731 0000E6B1 L302:
732 0000E6B1 6d effffff9ed incl _index
733 0000E6B7 13 fefa jbr L304
734 0000E6BA L303:
735 0000E6BA # } /* end of subtest 5 */
736 0000E6BA 40 ret#2
737 0000E6BB .set L298,0x0
738 0000E6BB L300:
739 0000E6BB 13 fee3 jbr L301
740 0000E6BE .data
741 00000d28 * .text
742 0000E6BE .align 1
743 0000E6BE .globl _subf_6
744 0000E6BE _subf_6:
745 0000E6BE 0000 .word L314
746 0000E6C0 #
747 0000E6C0 #
748 0000E6C0 #
749 0000E6C0 # /************************************************************************
750 0000E6C0 # *
751 0000E6C0 # * SUBTEST 6 - Check for register corruption
752 0000E6C0 # *
753 0000E6C0 # ************************************************************************/
754 0000E6C0 # subf_6()
755 0000E6C0 # {
756 0000E6C0 13 01a7 jbr L316
757 0000E6C3 L317:
758 0000E6C3 # force_loop = FALSE; /* clear force_loop flg */
759 0000E6C3 4d effffff9db clrl _force_loop
760 0000E6C9 # subtest = 6;
761 0000E6C9 0d 06 effffff9d4 movl $6,_subtest
762 0000E6D0 # fill_reg_buf( load_regs ); /* get patterns for regs */
763 0000E6D0 dd 8f00000000 pushl $_load_regs
764 0000E6D6 fe 08 effffff9c7 callf $8,_fill_reg_buf
765 0000E6DD # index = 0;
766 0000E6DD 4d effffff9c1 clrl _index
767 0000E6E3 # sgl_ld_acc = subf_1_data[0].op_1; /* get operand 1 */
768 0000E6E3 0d effffff9bb effffff9b6 movl _subf_1_data,_sgl_ld_acc
769 0000E6EE # sgl_value_1 = subf_1_data[0].op_2; /* get operand 2 */
770 0000E6EE 0d effffff9b4 effffff9ab movl _subf_1_data+4,_sgl_value_1
771 0000E6F9 # sgl_expected = subf_1_data[0].exp; /* get expected result */
772 0000E6F9 0d effffff9ad effffff9a0 movl _subf_1_data+8,_sgl_expected
773 0000E704 # /*
774 0000E704 # * If LOOP ON ERROR is set, this is the loop for this subtest.
775 0000E704 # * The force loop flag is set after the first error.
776 0000E704 # */
777 0000E704 # asm("_subf_6_lp1:");
778 0000E704 _subf_6_lp1:
779 0000E704 # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
780 0000E704 06 effffff99a ldf _sgl_ld_acc
781 0000E70A # asm("nop");
782 0000E70A 10 nop
783 0000E70B # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
784 0000E70B ab 891fff effffff990 loadr $0x1fff,_load_regs
785 0000E714 # asm("nop");
786 0000E714 10 nop
787 0000E715 # asm("subf _sgl_value_1"); /* do the subraction */
788 0000E715 d6 effffff989 subf _sgl_value_1
789 0000E71B # asm("nop");
790 0000E71B 10 nop
791 0000E71C # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
792 0000E71C bb 891fff effffff97f storer $0x1fff,_store_regs
793 0000E725 # asm("stf _sgl_st_acc"); /* save the accumulator */
794 0000E725 26 effffff979 stf _sgl_st_acc
795 0000E72B # if( force_loop )
796 0000E72B 5d effffff973 tstl _force_loop
797 0000E731 31 02 jeql L319
798 0000E733 # asm("brb _subf_6_lp1");; /* loop on the error */
799 0000E733 11 cf brb _subf_6_lp1
800 0000E735 L319:
801 0000E735 # /*
802 0000E735 # * Now compare the stored register values to those that were loaded
803 0000E735 # */
804 0000E735 # index2 = 0;
805 0000E735 4d effffff969 clrl _index2
806 0000E73B # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
807 0000E73B L320:
808 0000E73B 0d effffff963 50 movl _index2,r0
809 0000E742 0d effffff95c 51 movl _index2,r1
810 0000E749 1d 40effffff954 cmpl _load_regs[r0],_store_regs[r1]
41effffff94e
811 0000E756 21 11 jneq L321
812 0000E758 1d effffff946 0d cmpl _index2,$13
813 0000E75F 81 08 jgeq L321
814 0000E761 # index2++; /* check reg values */
815 0000E761 6d effffff93d incl _index2
816 0000E767 11 d2 jbr L320
817 0000E769 L321:
818 0000E769 # if( index2 < 13 ) { /* error if index2 < 13 */
819 0000E769 1d effffff935 0d cmpl _index2,$13
820 0000E770 91 03 13 00f4 jgeq L322
821 0000E775 # errcnt++; /* bump the error count */
822 0000E775 6d effffff929 incl _errcnt
823 0000E77B # if( prt_error ) {
824 0000E77B 5d effffff923 tstl _prt_error
825 0000E781 21 03 13 00c0 jeql L323
826 0000E786 # writes(" \n"); /* start a new print line */
827 0000E786 .data 1
828 00000e92 * L324:
829 00000e92 * 200A00 .ascii " \12\0"
830 00000e95 * .text
831 0000E786 dd 8f00000e92 pushl $L324
832 0000E78C fe 08 effffff911 callf $8,_writes
833 0000E793 # writes("cycle: ");
834 0000E793 .data 1
835 00000e95 * L325:
836 00000e95 * 6379636C653A2000 .ascii "cycle: \0"
837 00000e9d * .text
838 0000E793 dd 8f00000e95 pushl $L325
839 0000E799 fe 08 effffff904 callf $8,_writes
840 0000E7A0 # writed( cycle );
841 0000E7A0 dd effffff8fe pushl _cycle
842 0000E7A6 fe 08 effffff8f7 callf $8,_writed
843 0000E7AD # writes(" SUBF test ");
844 0000E7AD .data 1
845 00000e9d * L326:
846 00000e9d * 2020535542462074657374200 .ascii " SUBF test \0"
0
847 00000eaa * .text
848 0000E7AD dd 8f00000e9d pushl $L326
849 0000E7B3 fe 08 effffff8ea callf $8,_writes
850 0000E7BA # writed( test_no );
851 0000E7BA dd effffff8e4 pushl _test_no
852 0000E7C0 fe 08 effffff8dd callf $8,_writed
853 0000E7C7 # writes(", subtest 6 - A REGISTER WAS MODIFIED\n");
854 0000E7C7 .data 1
855 00000eaa * L327:
856 00000eaa * 2C20737562746573742036202 .ascii ", subtest 6 - A REGISTER WAS MODIFIED\12\0"
D204120524547495354455220
574153204D4F4449464945440
A00
857 00000ed1 * .text
858 0000E7C7 dd 8f00000eaa pushl $L327
859 0000E7CD fe 08 effffff8d0 callf $8,_writes
860 0000E7D4 # print_subf_data(); /* print the operands */
861 0000E7D4 fe 04 ef00000499 callf $4,_print_subf_data
862 0000E7DB # writes("register "); /* print the information */
863 0000E7DB .data 1
864 00000ed1 * L328:
865 00000ed1 * 72656769737465722000 .ascii "register \0"
866 00000edb * .text
867 0000E7DB dd 8f00000ed1 pushl $L328
868 0000E7E1 fe 08 effffff8bc callf $8,_writes
869 0000E7E8 # writed( index2 ); /* about the corrupted */
870 0000E7E8 dd effffff8b6 pushl _index2
871 0000E7EE fe 08 effffff8af callf $8,_writed
872 0000E7F5 # writes(" = "); /* register */
873 0000E7F5 .data 1
874 00000edb * L329:
875 00000edb * 203D2000 .ascii " = \0"
876 00000edf * .text
877 0000E7F5 dd 8f00000edb pushl $L329
878 0000E7FB fe 08 effffff8a2 callf $8,_writes
879 0000E802 # write32h( store_regs[index2] );
880 0000E802 0d effffff89c 50 movl _index2,r0
881 0000E809 dd 40effffff894 pushl _store_regs[r0]
882 0000E810 fe 08 effffff88d callf $8,_write32h
883 0000E817 # writes(", should be = ");
884 0000E817 .data 1
885 00000edf * L331:
886 00000edf * 2C202073686F756C642062652 .ascii ", should be = \0"
03D2000
887 00000eef * .text
888 0000E817 dd 8f00000edf pushl $L331
889 0000E81D fe 08 effffff880 callf $8,_writes
890 0000E824 # write32h( load_regs[index2] );
891 0000E824 0d effffff87a 50 movl _index2,r0
892 0000E82B dd 40effffff872 pushl _load_regs[r0]
893 0000E832 fe 08 effffff86b callf $8,_write32h
894 0000E839 # writes("\n");
895 0000E839 .data 1
896 00000eef * L332:
897 00000eef * 0A00 .ascii "\12\0"
898 00000ef1 * .text
899 0000E839 dd 8f00000eef pushl $L332
900 0000E83F fe 08 effffff85e callf $8,_writes
901 0000E846 # }
902 0000E846 # if( halt_flg )
903 0000E846 L323:
904 0000E846 5d effffff858 tstl _halt_flg
905 0000E84C 31 09 jeql L333
906 0000E84E # subf_er_halt( BAD_REG_HLT ); /* halt on the error */
907 0000E84E dd 02 pushl $2
908 0000E850 fe 08 ef000004bb callf $8,_subf_er_halt
909 0000E857 # if( loop_on_err ) {
910 0000E857 L333:
911 0000E857 5d effffff847 tstl _loop_on_err
912 0000E85D 31 0a jeql L334
913 0000E85F # force_loop = TRUE; /* set the force loop flag */
914 0000E85F 0d 01 effffff83e movl $1,_force_loop
915 0000E866 # asm("brw _subf_6_lp1");; /* and loop on the error */
916 0000E866 13 fe9b brw _subf_6_lp1
917 0000E869 # } /* end of loop on error */
918 0000E869 # } /* end of register corruption error */
919 0000E869 L334:
920 0000E869 # } /* end of subtest 6 */
921 0000E869 L322:
922 0000E869 40 ret#2
923 0000E86A .set L314,0x0
924 0000E86A L316:
925 0000E86A 13 fe56 jbr L317
926 0000E86D .data
927 00000d28 * .text
928 0000E86D 00 .align 1
929 0000E86E .globl _subf_7
930 0000E86E _subf_7:
931 0000E86E 0000 .word L335
932 0000E870 #
933 0000E870 #
934 0000E870 #
935 0000E870 # /************************************************************************
936 0000E870 # *
937 0000E870 # * SUBTEST 7 - Check for PSL corruption
938 0000E870 # *
939 0000E870 # ************************************************************************/
940 0000E870 # subf_7()
941 0000E870 # {
942 0000E870 13 01b1 jbr L337
943 0000E873 L338:
944 0000E873 # force_loop = FALSE; /* clear force_loop flg */
945 0000E873 4d effffff82b clrl _force_loop
946 0000E879 # subtest = 7;
947 0000E879 0d 07 effffff824 movl $7,_subtest
948 0000E880 # fill_reg_buf( load_regs ); /* get patterns for regs */
949 0000E880 dd 8f00000000 pushl $_load_regs
950 0000E886 fe 08 effffff817 callf $8,_fill_reg_buf
951 0000E88D # for( index = 0; index < 3; index++ ) {
952 0000E88D 4d effffff811 clrl _index
953 0000E893 L341:
954 0000E893 1d effffff80b 03 cmpl _index,$3
955 0000E89A 91 03 13 0184 jgeq L340
956 0000E89F # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
957 0000E89F 5c 0c effffff7fe 50 mull3 $12,_index,r0
958 0000E8A7 0d e000000000 effffff7f2 movl _subf_1_data(r0),_sgl_ld_acc
959 0000E8B2 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
960 0000E8B2 5c 0c effffff7eb 50 mull3 $12,_index,r0
961 0000E8BA 0d e000000004 effffff7df movl _subf_1_data+4(r0),_sgl_value_1
962 0000E8C5 # sgl_expected = subf_1_data[index].exp; /* get expected */
963 0000E8C5 5c 0c effffff7d8 50 mull3 $12,_index,r0
964 0000E8CD 0d e000000008 effffff7cc movl _subf_1_data+8(r0),_sgl_expected
965 0000E8D8 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
966 0000E8D8 0d effffff7c6 50 movl _status_index,r0
967 0000E8DF 0d 40effffff7be movl _status_array[r0],_sgl_dummy1
effffff7b9
968 0000E8EB # /*
969 0000E8EB # * If LOOP ON ERROR is set, this is the loop for this subtest.
970 0000E8EB # * The force loop flag is set after the first error.
971 0000E8EB # */
972 0000E8EB # asm("_subf_7_lp1:");
973 0000E8EB _subf_7_lp1:
974 0000E8EB # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
975 0000E8EB 06 effffff7b3 ldf _sgl_ld_acc
976 0000E8F1 # asm("nop");
977 0000E8F1 10 nop
978 0000E8F2 # asm("tstl _sgl_dummy1"); /* set the PSL status */
979 0000E8F2 5d effffff7ac tstl _sgl_dummy1
980 0000E8F8 # asm("movpsl _init_psl"); /* save the initial PSL */
981 0000E8F8 cd effffff7a6 movpsl _init_psl
982 0000E8FE # asm("subf _sgl_value_1"); /* do the subract */
983 0000E8FE d6 effffff7a0 subf _sgl_value_1
984 0000E904 # asm("nop");
985 0000E904 10 nop
986 0000E905 # asm("movpsl _psl_val"); /* save the final PSL */
987 0000E905 cd effffff799 movpsl _psl_val
988 0000E90B # asm("stf _sgl_st_acc"); /* save the accumulator */
989 0000E90B 26 effffff793 stf _sgl_st_acc
990 0000E911 # if( force_loop )
991 0000E911 5d effffff78d tstl _force_loop
992 0000E917 31 02 jeql L342
993 0000E919 # asm("brb _subf_7_lp1");; /* loop on the error */
994 0000E919 11 d0 brb _subf_7_lp1
995 0000E91B L342:
996 0000E91B # /*
997 0000E91B # * Now compare the final PSL to the initial PSL -they should be the same
998 0000E91B # */
999 0000E91B # exp_psl = init_psl;
1000 0000E91B 0d effffff783 effffff77e movl _init_psl,_exp_psl
1001 0000E926 # if( psl_val != init_psl ) {
1002 0000E926 1d effffff778 effffff773 cmpl _psl_val,_init_psl
1003 0000E931 21 03 13 00e4 jeql L343
1004 0000E936 # errcnt++; /* bump the error count */
1005 0000E936 6d effffff768 incl _errcnt
1006 0000E93C # if( prt_error ) {
1007 0000E93C 5d effffff762 tstl _prt_error
1008 0000E942 21 03 13 00b0 jeql L344
1009 0000E947 # writes(" \n"); /* start a new print line */
1010 0000E947 .data 1
1011 00000ef1 * L345:
1012 00000ef1 * 200A00 .ascii " \12\0"
1013 00000ef4 * .text
1014 0000E947 dd 8f00000ef1 pushl $L345
1015 0000E94D fe 08 effffff750 callf $8,_writes
1016 0000E954 # writes("cycle: ");
1017 0000E954 .data 1
1018 00000ef4 * L346:
1019 00000ef4 * 6379636C653A2000 .ascii "cycle: \0"
1020 00000efc * .text
1021 0000E954 dd 8f00000ef4 pushl $L346
1022 0000E95A fe 08 effffff743 callf $8,_writes
1023 0000E961 # writed( cycle );
1024 0000E961 dd effffff73d pushl _cycle
1025 0000E967 fe 08 effffff736 callf $8,_writed
1026 0000E96E # writes(" SUBF test ");
1027 0000E96E .data 1
1028 00000efc * L347:
1029 00000efc * 2020535542462074657374200 .ascii " SUBF test \0"
0
1030 00000f09 * .text
1031 0000E96E dd 8f00000efc pushl $L347
1032 0000E974 fe 08 effffff729 callf $8,_writes
1033 0000E97B # writed( test_no );
1034 0000E97B dd effffff723 pushl _test_no
1035 0000E981 fe 08 effffff71c callf $8,_writed
1036 0000E988 # writes(", subtest 7 - INCORRECT FINAL PSL\n");
1037 0000E988 .data 1
1038 00000f09 * L348:
1039 00000f09 * 2C20737562746573742037202 .ascii ", subtest 7 - INCORRECT FINAL PSL\12\0"
D20494E434F52524543542046
494E414C2050534C0A00
1040 00000f2c * .text
1041 0000E988 dd 8f00000f09 pushl $L348
1042 0000E98E fe 08 effffff70f callf $8,_writes
1043 0000E995 # print_subf_data(); /* print the operands */
1044 0000E995 fe 04 ef000002d8 callf $4,_print_subf_data
1045 0000E99C # writes("initial PSL = ");
1046 0000E99C .data 1
1047 00000f2c * L349:
1048 00000f2c * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
1049 00000f3b * .text
1050 0000E99C dd 8f00000f2c pushl $L349
1051 0000E9A2 fe 08 effffff6fb callf $8,_writes
1052 0000E9A9 # write32h( init_psl );
1053 0000E9A9 dd effffff6f5 pushl _init_psl
1054 0000E9AF fe 08 effffff6ee callf $8,_write32h
1055 0000E9B6 # writes(", final PSL = ");
1056 0000E9B6 .data 1
1057 00000f3b * L350:
1058 00000f3b * 2C2066696E616C2050534C203 .ascii ", final PSL = \0"
D2000
1059 00000f4a * .text
1060 0000E9B6 dd 8f00000f3b pushl $L350
1061 0000E9BC fe 08 effffff6e1 callf $8,_writes
1062 0000E9C3 # write32h( psl_val );
1063 0000E9C3 dd effffff6db pushl _psl_val
1064 0000E9C9 fe 08 effffff6d4 callf $8,_write32h
1065 0000E9D0 # writes(", expected PSL = ");
1066 0000E9D0 .data 1
1067 00000f4a * L351:
1068 00000f4a * 2C20657870656374656420505 .ascii ", expected PSL = \0"
34C203D2000
1069 00000f5c * .text
1070 0000E9D0 dd 8f00000f4a pushl $L351
1071 0000E9D6 fe 08 effffff6c7 callf $8,_writes
1072 0000E9DD # write32h( exp_psl );
1073 0000E9DD dd effffff6c1 pushl _exp_psl
1074 0000E9E3 fe 08 effffff6ba callf $8,_write32h
1075 0000E9EA # writes("\n");
1076 0000E9EA .data 1
1077 00000f5c * L352:
1078 00000f5c * 0A00 .ascii "\12\0"
1079 00000f5e * .text
1080 0000E9EA dd 8f00000f5c pushl $L352
1081 0000E9F0 fe 08 effffff6ad callf $8,_writes
1082 0000E9F7 # }
1083 0000E9F7 # if( halt_flg )
1084 0000E9F7 L344:
1085 0000E9F7 5d effffff6a7 tstl _halt_flg
1086 0000E9FD 31 09 jeql L353
1087 0000E9FF # subf_er_halt( BAD_PSL_HLT ); /* halt on the error */
1088 0000E9FF dd 03 pushl $3
1089 0000EA01 fe 08 ef0000030a callf $8,_subf_er_halt
1090 0000EA08 # if( loop_on_err ) {
1091 0000EA08 L353:
1092 0000EA08 5d effffff696 tstl _loop_on_err
1093 0000EA0E 31 0a jeql L354
1094 0000EA10 # force_loop = TRUE; /* set the force loop flag */
1095 0000EA10 0d 01 effffff68d movl $1,_force_loop
1096 0000EA17 # asm("brw _subf_7_lp1");; /* and loop on the error */
1097 0000EA17 13 fed1 brw _subf_7_lp1
1098 0000EA1A # } /* end of loop on error */
1099 0000EA1A # } /* end of PSL corruption error */
1100 0000EA1A L354:
1101 0000EA1A # } /* end of WHILE loop */
1102 0000EA1A L343:
1103 0000EA1A L339:
1104 0000EA1A 6d effffff684 incl _index
1105 0000EA20 13 fe70 jbr L341
1106 0000EA23 L340:
1107 0000EA23 # } /* end of subtest 7 */
1108 0000EA23 40 ret#2
1109 0000EA24 .set L335,0x0
1110 0000EA24 L337:
1111 0000EA24 13 fe4c jbr L338
1112 0000EA27 .data
1113 00000d28 * .text
1114 0000EA27 00 .align 1
1115 0000EA28 .globl _subf_8
1116 0000EA28 _subf_8:
1117 0000EA28 0000 .word L355
1118 0000EA2A #
1119 0000EA2A #
1120 0000EA2A #
1121 0000EA2A # /************************************************************************
1122 0000EA2A # *
1123 0000EA2A # * SUBTEST 8 - pipelined entry test
1124 0000EA2A # *
1125 0000EA2A # ************************************************************************/
1126 0000EA2A # subf_8()
1127 0000EA2A # {
1128 0000EA2A 13 011d jbr L357
1129 0000EA2D L358:
1130 0000EA2D # force_loop = FALSE;
1131 0000EA2D 4d effffff671 clrl _force_loop
1132 0000EA33 # subtest = 8;
1133 0000EA33 0d 08 effffff66a movl $8,_subtest
1134 0000EA3A # for( index = 0; index < max_subf_1_index; index++ ) {
1135 0000EA3A 4d effffff664 clrl _index
1136 0000EA40 L361:
1137 0000EA40 1d effffff65e effffff659 cmpl _index,_max_subf_1_index
1138 0000EA4B 91 03 13 00f9 jgeq L360
1139 0000EA50 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
1140 0000EA50 5c 0c effffff64d 50 mull3 $12,_index,r0
1141 0000EA58 0d e000000000 effffff641 movl _subf_1_data(r0),_sgl_ld_acc
1142 0000EA63 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
1143 0000EA63 5c 0c effffff63a 50 mull3 $12,_index,r0
1144 0000EA6B 0d e000000004 effffff62e movl _subf_1_data+4(r0),_sgl_value_1
1145 0000EA76 # sgl_expected = subf_1_data[index].exp; /* get expected result */
1146 0000EA76 5c 0c effffff627 50 mull3 $12,_index,r0
1147 0000EA7E 0d e000000008 effffff61b movl _subf_1_data+8(r0),_sgl_expected
1148 0000EA89 # /*
1149 0000EA89 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1150 0000EA89 # * The force loop flag is set after the first error.
1151 0000EA89 # */
1152 0000EA89 # asm("_subf_8_lp1:");
1153 0000EA89 _subf_8_lp1:
1154 0000EA89 # asm("movl $0,r0"); /* clear r0 */
1155 0000EA89 0d 00 50 movl $0,r0
1156 0000EA8C # asm("ldf r0"); /* load the Acc. with 0.0 */
1157 0000EA8C 06 50 ldf r0
1158 0000EA8E # asm("addf _sgl_ld_acc"); /* add the 1st operand */
1159 0000EA8E c6 effffff610 addf _sgl_ld_acc
1160 0000EA94 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
1161 0000EA94 d6 effffff60a subf _sgl_value_1
1162 0000EA9A # asm("stf _sgl_st_acc"); /* store the result */
1163 0000EA9A 26 effffff604 stf _sgl_st_acc
1164 0000EAA0 # if( force_loop )
1165 0000EAA0 5d effffff5fe tstl _force_loop
1166 0000EAA6 31 02 jeql L362
1167 0000EAA8 # asm("brb _subf_8_lp1");; /* loop on the error */
1168 0000EAA8 11 df brb _subf_8_lp1
1169 0000EAAA L362:
1170 0000EAAA # /*
1171 0000EAAA # * end error loop - test the results
1172 0000EAAA # */
1173 0000EAAA # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1174 0000EAAA 1d effffff5f4 effffff5ef cmpl _sgl_st_acc,_sgl_expected
1175 0000EAB5 21 03 13 0086 jeql L363
1176 0000EABA # errcnt++; /* bump the error count */
1177 0000EABA 6d effffff5e4 incl _errcnt
1178 0000EAC0 # if( prt_error ) {
1179 0000EAC0 5d effffff5de tstl _prt_error
1180 0000EAC6 31 55 jeql L364
1181 0000EAC8 # writes(" \n"); /* start a new print line */
1182 0000EAC8 .data 1
1183 00000f5e * L365:
1184 00000f5e * 200A00 .ascii " \12\0"
1185 00000f61 * .text
1186 0000EAC8 dd 8f00000f5e pushl $L365
1187 0000EACE fe 08 effffff5cf callf $8,_writes
1188 0000EAD5 # writes("cycle: ");
1189 0000EAD5 .data 1
1190 00000f61 * L366:
1191 00000f61 * 6379636C653A2000 .ascii "cycle: \0"
1192 00000f69 * .text
1193 0000EAD5 dd 8f00000f61 pushl $L366
1194 0000EADB fe 08 effffff5c2 callf $8,_writes
1195 0000EAE2 # writed( cycle );
1196 0000EAE2 dd effffff5bc pushl _cycle
1197 0000EAE8 fe 08 effffff5b5 callf $8,_writed
1198 0000EAEF # writes(" SUBF test ");
1199 0000EAEF .data 1
1200 00000f69 * L367:
1201 00000f69 * 2020535542462074657374200 .ascii " SUBF test \0"
0
1202 00000f76 * .text
1203 0000EAEF dd 8f00000f69 pushl $L367
1204 0000EAF5 fe 08 effffff5a8 callf $8,_writes
1205 0000EAFC # writed( test_no );
1206 0000EAFC dd effffff5a2 pushl _test_no
1207 0000EB02 fe 08 effffff59b callf $8,_writed
1208 0000EB09 # writes(", subtest 8 (Piped Entry) - BAD FINAL ACC\n");
1209 0000EB09 .data 1
1210 00000f76 * L368:
1211 00000f76 * 2C20737562746573742038202 .ascii ", subtest 8 (Piped Entry) - BAD FINAL ACC\12\0"
8506970656420456E74727929
202D204241442046494E414C2
04143430A00
1212 00000fa1 * .text
1213 0000EB09 dd 8f00000f76 pushl $L368
1214 0000EB0F fe 08 effffff58e callf $8,_writes
1215 0000EB16 # print_subf_data();
1216 0000EB16 fe 04 ef00000157 callf $4,_print_subf_data
1217 0000EB1D # }
1218 0000EB1D # if( halt_flg )
1219 0000EB1D L364:
1220 0000EB1D 5d effffff581 tstl _halt_flg
1221 0000EB23 31 09 jeql L369
1222 0000EB25 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1223 0000EB25 dd 01 pushl $1
1224 0000EB27 fe 08 ef000001e4 callf $8,_subf_er_halt
1225 0000EB2E # if( loop_on_err ) {
1226 0000EB2E L369:
1227 0000EB2E 5d effffff570 tstl _loop_on_err
1228 0000EB34 31 0a jeql L370
1229 0000EB36 # force_loop = TRUE; /* set the force loop flag */
1230 0000EB36 0d 01 effffff567 movl $1,_force_loop
1231 0000EB3D # asm("brw _subf_8_lp1");; /* and loop on the error */
1232 0000EB3D 13 ff49 brw _subf_8_lp1
1233 0000EB40 # } /* end of loop on error */
1234 0000EB40 # } /* end of compare error */
1235 0000EB40 L370:
1236 0000EB40 # } /* end of WHILE loop */
1237 0000EB40 L363:
1238 0000EB40 L359:
1239 0000EB40 6d effffff55e incl _index
1240 0000EB46 13 fef7 jbr L361
1241 0000EB49 L360:
1242 0000EB49 # } /* end of subtest 8 */
1243 0000EB49 40 ret#2
1244 0000EB4A .set L355,0x0
1245 0000EB4A L357:
1246 0000EB4A 13 fee0 jbr L358
1247 0000EB4D .data
1248 00000d28 * .text
1249 0000EB4D 00 .align 1
1250 0000EB4E .globl _subf_9
1251 0000EB4E _subf_9:
1252 0000EB4E 0000 .word L371
1253 0000EB50 #
1254 0000EB50 #
1255 0000EB50 #
1256 0000EB50 # /************************************************************************
1257 0000EB50 # *
1258 0000EB50 # * SUBTEST 9 - pipelined exit test
1259 0000EB50 # *
1260 0000EB50 # ************************************************************************/
1261 0000EB50 # subf_9()
1262 0000EB50 # {
1263 0000EB50 13 011d jbr L373
1264 0000EB53 L374:
1265 0000EB53 # force_loop = FALSE;
1266 0000EB53 4d effffff54b clrl _force_loop
1267 0000EB59 # subtest = 9;
1268 0000EB59 0d 09 effffff544 movl $9,_subtest
1269 0000EB60 # for( index = 0; index < max_subf_1_index; index++ ) {
1270 0000EB60 4d effffff53e clrl _index
1271 0000EB66 L377:
1272 0000EB66 1d effffff538 effffff533 cmpl _index,_max_subf_1_index
1273 0000EB71 91 03 13 00f9 jgeq L376
1274 0000EB76 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
1275 0000EB76 5c 0c effffff527 50 mull3 $12,_index,r0
1276 0000EB7E 0d e000000000 effffff51b movl _subf_1_data(r0),_sgl_ld_acc
1277 0000EB89 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
1278 0000EB89 5c 0c effffff514 50 mull3 $12,_index,r0
1279 0000EB91 0d e000000004 effffff508 movl _subf_1_data+4(r0),_sgl_value_1
1280 0000EB9C # sgl_expected = subf_1_data[index].exp; /* get expected result */
1281 0000EB9C 5c 0c effffff501 50 mull3 $12,_index,r0
1282 0000EBA4 0d e000000008 effffff4f5 movl _subf_1_data+8(r0),_sgl_expected
1283 0000EBAF # /*
1284 0000EBAF # * If LOOP ON ERROR is set, this is the loop for this subtest.
1285 0000EBAF # * The force loop flag is set after the first error.
1286 0000EBAF # */
1287 0000EBAF # asm("_subf_9_lp1:");
1288 0000EBAF _subf_9_lp1:
1289 0000EBAF # asm("movl $0,r0"); /* clear r0 */
1290 0000EBAF 0d 00 50 movl $0,r0
1291 0000EBB2 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
1292 0000EBB2 06 effffff4ec ldf _sgl_ld_acc
1293 0000EBB8 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
1294 0000EBB8 d6 effffff4e6 subf _sgl_value_1
1295 0000EBBE # asm("addf r0"); /* add a 0.0 to the result */
1296 0000EBBE c6 50 addf r0
1297 0000EBC0 # asm("stf _sgl_st_acc"); /* store the result */
1298 0000EBC0 26 effffff4de stf _sgl_st_acc
1299 0000EBC6 # if( force_loop )
1300 0000EBC6 5d effffff4d8 tstl _force_loop
1301 0000EBCC 31 02 jeql L378
1302 0000EBCE # asm("brb _subf_9_lp1");; /* loop on the error */
1303 0000EBCE 11 df brb _subf_9_lp1
1304 0000EBD0 L378:
1305 0000EBD0 # /*
1306 0000EBD0 # * end error loop - test the results
1307 0000EBD0 # */
1308 0000EBD0 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1309 0000EBD0 1d effffff4ce effffff4c9 cmpl _sgl_st_acc,_sgl_expected
1310 0000EBDB 21 03 13 0086 jeql L379
1311 0000EBE0 # errcnt++; /* bump the error count */
1312 0000EBE0 6d effffff4be incl _errcnt
1313 0000EBE6 # if( prt_error ) {
1314 0000EBE6 5d effffff4b8 tstl _prt_error
1315 0000EBEC 31 55 jeql L380
1316 0000EBEE # writes(" \n"); /* start a new print line */
1317 0000EBEE .data 1
1318 00000fa1 * L381:
1319 00000fa1 * 200A00 .ascii " \12\0"
1320 00000fa4 * .text
1321 0000EBEE dd 8f00000fa1 pushl $L381
1322 0000EBF4 fe 08 effffff4a9 callf $8,_writes
1323 0000EBFB # writes("cycle: ");
1324 0000EBFB .data 1
1325 00000fa4 * L382:
1326 00000fa4 * 6379636C653A2000 .ascii "cycle: \0"
1327 00000fac * .text
1328 0000EBFB dd 8f00000fa4 pushl $L382
1329 0000EC01 fe 08 effffff49c callf $8,_writes
1330 0000EC08 # writed( cycle );
1331 0000EC08 dd effffff496 pushl _cycle
1332 0000EC0E fe 08 effffff48f callf $8,_writed
1333 0000EC15 # writes(" SUBF test ");
1334 0000EC15 .data 1
1335 00000fac * L383:
1336 00000fac * 2020535542462074657374200 .ascii " SUBF test \0"
0
1337 00000fb9 * .text
1338 0000EC15 dd 8f00000fac pushl $L383
1339 0000EC1B fe 08 effffff482 callf $8,_writes
1340 0000EC22 # writed( test_no );
1341 0000EC22 dd effffff47c pushl _test_no
1342 0000EC28 fe 08 effffff475 callf $8,_writed
1343 0000EC2F # writes(", subtest 9 (Piped Exit) - BAD FINAL ACC\n");
1344 0000EC2F .data 1
1345 00000fb9 * L384:
1346 00000fb9 * 2C20737562746573742039202 .ascii ", subtest 9 (Piped Exit) - BAD FINAL ACC\12\0"
8506970656420457869742920
2D204241442046494E414C204
143430A00
1347 00000fe3 * .text
1348 0000EC2F dd 8f00000fb9 pushl $L384
1349 0000EC35 fe 08 effffff468 callf $8,_writes
1350 0000EC3C # print_subf_data();
1351 0000EC3C fe 04 ef00000031 callf $4,_print_subf_data
1352 0000EC43 # }
1353 0000EC43 # if( halt_flg )
1354 0000EC43 L380:
1355 0000EC43 5d effffff45b tstl _halt_flg
1356 0000EC49 31 09 jeql L385
1357 0000EC4B # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1358 0000EC4B dd 01 pushl $1
1359 0000EC4D fe 08 ef000000be callf $8,_subf_er_halt
1360 0000EC54 # if( loop_on_err ) {
1361 0000EC54 L385:
1362 0000EC54 5d effffff44a tstl _loop_on_err
1363 0000EC5A 31 0a jeql L386
1364 0000EC5C # force_loop = TRUE; /* set the force loop flag */
1365 0000EC5C 0d 01 effffff441 movl $1,_force_loop
1366 0000EC63 # asm("brw _subf_9_lp1");; /* and loop on the error */
1367 0000EC63 13 ff49 brw _subf_9_lp1
1368 0000EC66 # } /* end of loop on error */
1369 0000EC66 # } /* end of compare error */
1370 0000EC66 L386:
1371 0000EC66 # } /* end of WHILE loop */
1372 0000EC66 L379:
1373 0000EC66 L375:
1374 0000EC66 6d effffff438 incl _index
1375 0000EC6C 13 fef7 jbr L377
1376 0000EC6F L376:
1377 0000EC6F # } /* end of subtest 9 */
1378 0000EC6F 40 ret#2
1379 0000EC70 .set L371,0x0
1380 0000EC70 L373:
1381 0000EC70 13 fee0 jbr L374
1382 0000EC73 .data
1383 00000d28 * .text
1384 0000EC73 00 .align 1
1385 0000EC74 .globl _print_subf_data
1386 0000EC74 _print_subf_data:
1387 0000EC74 0000 .word L387
1388 0000EC76 #
1389 0000EC76 #
1390 0000EC76 #
1391 0000EC76 # /**************************************************************************
1392 0000EC76 # *
1393 0000EC76 # * PRINT THE DATA AND STORE RESULTS
1394 0000EC76 # *
1395 0000EC76 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1396 0000EC76 # * operand = xxxxxxxx, expected = xxxxxxxx
1397 0000EC76 # **************************************************************************/
1398 0000EC76 # print_subf_data()
1399 0000EC76 # {
1400 0000EC76 13 0095 jbr L389
1401 0000EC79 L390:
1402 0000EC79 # writes("initial Acc = ");
1403 0000EC79 .data 1
1404 00000fe3 * L391:
1405 00000fe3 * 696E697469616C20416363203 .ascii "initial Acc = \0"
D2000
1406 00000ff2 * .text
1407 0000EC79 dd 8f00000fe3 pushl $L391
1408 0000EC7F fe 08 effffff41e callf $8,_writes
1409 0000EC86 # write32h( sgl_ld_acc );
1410 0000EC86 dd effffff418 pushl _sgl_ld_acc
1411 0000EC8C fe 08 effffff411 callf $8,_write32h
1412 0000EC93 # writes(", stored = ");
1413 0000EC93 .data 1
1414 00000ff2 * L392:
1415 00000ff2 * 2C2020202073746F726564203 .ascii ", stored = \0"
D2000
1416 00001001 * .text
1417 0000EC93 dd 8f00000ff2 pushl $L392
1418 0000EC99 fe 08 effffff404 callf $8,_writes
1419 0000ECA0 # write32h( sgl_st_acc );
1420 0000ECA0 dd effffff3fe pushl _sgl_st_acc
1421 0000ECA6 fe 08 effffff3f7 callf $8,_write32h
1422 0000ECAD # writes(", data index = ");
1423 0000ECAD .data 1
1424 00001001 * L393:
1425 00001001 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
1426 00001012 * .text
1427 0000ECAD dd 8f00001001 pushl $L393
1428 0000ECB3 fe 08 effffff3ea callf $8,_writes
1429 0000ECBA # writed( index );
1430 0000ECBA dd effffff3e4 pushl _index
1431 0000ECC0 fe 08 effffff3dd callf $8,_writed
1432 0000ECC7 # writec('\n');
1433 0000ECC7 dd 0a pushl $10
1434 0000ECC9 fe 08 effffff3d4 callf $8,_writec
1435 0000ECD0 # writes(" operand = ");
1436 0000ECD0 .data 1
1437 00001012 * L395:
1438 00001012 * 202020206F706572616E64203 .ascii " operand = \0"
D2000
1439 00001021 * .text
1440 0000ECD0 dd 8f00001012 pushl $L395
1441 0000ECD6 fe 08 effffff3c7 callf $8,_writes
1442 0000ECDD # write32h( sgl_value_1 );
1443 0000ECDD dd effffff3c1 pushl _sgl_value_1
1444 0000ECE3 fe 08 effffff3ba callf $8,_write32h
1445 0000ECEA # writes(", expected = ");
1446 0000ECEA .data 1
1447 00001021 * L396:
1448 00001021 * 2C20206578706563746564203 .ascii ", expected = \0"
D2000
1449 00001030 * .text
1450 0000ECEA dd 8f00001021 pushl $L396
1451 0000ECF0 fe 08 effffff3ad callf $8,_writes
1452 0000ECF7 # write32h( sgl_expected );
1453 0000ECF7 dd effffff3a7 pushl _sgl_expected
1454 0000ECFD fe 08 effffff3a0 callf $8,_write32h
1455 0000ED04 # writec('\n');
1456 0000ED04 dd 0a pushl $10
1457 0000ED06 fe 08 effffff397 callf $8,_writec
1458 0000ED0D # }
1459 0000ED0D 40 ret#2
1460 0000ED0E .set L387,0x0
1461 0000ED0E L389:
1462 0000ED0E 13 ff68 jbr L390
1463 0000ED11 .data
1464 00000d28 * .text
1465 0000ED11 00 .align 1
1466 0000ED12 .globl _subf_er_halt
1467 0000ED12 _subf_er_halt:
1468 0000ED12 0000 .word L397
1469 0000ED14 #
1470 0000ED14 #
1471 0000ED14 #
1472 0000ED14 # /**************************************************************************
1473 0000ED14 # *
1474 0000ED14 # * HALT ON ERROR ROUTINE
1475 0000ED14 # *
1476 0000ED14 # **************************************************************************/
1477 0000ED14 # subf_er_halt( halt_code )
1478 0000ED14 # int halt_code;
1479 0000ED14 # {
1480 0000ED14 13 00af jbr L399
1481 0000ED17 L400:
1482 0000ED17 # sgl_dummy1 = halt_code; /* get the error type */
1483 0000ED17 0d ad04 effffff385 movl 4(fp),_sgl_dummy1
1484 0000ED1F # asm("movl _test_no,r0"); /* r0 = test number */
1485 0000ED1F 0d effffff37f 50 movl _test_no,r0
1486 0000ED26 # asm("movl _subtest,r1"); /* r1 = subtest number */
1487 0000ED26 0d effffff378 51 movl _subtest,r1
1488 0000ED2D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1489 0000ED2D 0d effffff371 52 movl _sgl_dummy1,r2
1490 0000ED34 # asm("movl _cycle,r3"); /* r3 = cycle count */
1491 0000ED34 0d effffff36a 53 movl _cycle,r3
1492 0000ED3B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1493 0000ED3B 0d effffff363 54 movl _sgl_ld_acc,r4
1494 0000ED42 # asm("movl _sgl_value_1,r5"); /* r5 = data subtracted */
1495 0000ED42 0d effffff35c 55 movl _sgl_value_1,r5
1496 0000ED49 # asm("movl _sgl_st_acc,r6"); /* r6 = data stored */
1497 0000ED49 0d effffff355 56 movl _sgl_st_acc,r6
1498 0000ED50 # if(halt_code == BAD_ACC_HLT ) {
1499 0000ED50 1d ad04 01 cmpl 4(fp),$1
1500 0000ED54 21 10 jneq L401
1501 0000ED56 # asm("movl _sgl_expected,r7"); /* r7 = data expected */
1502 0000ED56 0d effffff348 57 movl _sgl_expected,r7
1503 0000ED5D # asm("movl _index,r8"); /* r8 = data index */
1504 0000ED5D 0d effffff341 58 movl _index,r8
1505 0000ED64 # } else
1506 0000ED64 11 5e jbr L402
1507 0000ED66 L401:
1508 0000ED66 # if( halt_code == BAD_REG_HLT ) {
1509 0000ED66 1d ad04 02 cmpl 4(fp),$2
1510 0000ED6A 21 3d jneq L403
1511 0000ED6C # sgl_dummy1 = load_regs[index2];
1512 0000ED6C 0d effffff332 50 movl _index2,r0
1513 0000ED73 0d 40effffff32a movl _load_regs[r0],_sgl_dummy1
effffff325
1514 0000ED7F # sgl_dummy2 = store_regs[index2];
1515 0000ED7F 0d effffff31f 50 movl _index2,r0
1516 0000ED86 0d 40effffff317 movl _store_regs[r0],_sgl_dummy2
effffff312
1517 0000ED92 # asm("movl _index2,r7"); /* r7 = bad register # */
1518 0000ED92 0d effffff30c 57 movl _index2,r7
1519 0000ED99 # asm("movl _sgl_dummy2,r8"); /* r8 = actual value */
1520 0000ED99 0d effffff305 58 movl _sgl_dummy2,r8
1521 0000EDA0 # asm("movl _sgl_dummy1,r9"); /* r9 = expected value */
1522 0000EDA0 0d effffff2fe 59 movl _sgl_dummy1,r9
1523 0000EDA7 # } else
1524 0000EDA7 11 1b jbr L404
1525 0000EDA9 L403:
1526 0000EDA9 # if( halt_code == BAD_PSL_HLT ) {
1527 0000EDA9 1d ad04 03 cmpl 4(fp),$3
1528 0000EDAD 21 15 jneq L405
1529 0000EDAF # asm("movl _init_psl,r7"); /* r7 = initial PSL */
1530 0000EDAF 0d effffff2ef 57 movl _init_psl,r7
1531 0000EDB6 # asm("movl _psl_val,r8"); /* r8 = final PSL */
1532 0000EDB6 0d effffff2e8 58 movl _psl_val,r8
1533 0000EDBD # asm("movl _exp_psl,r9"); /* r9 = expected PSL */
1534 0000EDBD 0d effffff2e1 59 movl _exp_psl,r9
1535 0000EDC4 # };
1536 0000EDC4 L405:
1537 0000EDC4 L404:
1538 0000EDC4 L402:
1539 0000EDC4 # asm("halt"); /* HALT ... */
1540 0000EDC4 00 halt
1541 0000EDC5 # }
1542 0000EDC5 40 ret#2
1543 0000EDC6 .set L397,0x0
1544 0000EDC6 L399:
1545 0000EDC6 13 ff4e jbr L400
1546 0000EDC9 .data
1546 0001CE6D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.