![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to negf.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 negf.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 000008c8 * .text
4 00000000 .align 1
5 00000000 .globl _negf
6 00000000 _negf:
7 0001114C 0000 .word L215
8 0001114E #
9 0001114E # #include "fpp_defs.h"
10 0001114E #
11 0001114E #
12 0001114E # /*****************************************************************************
13 0001114E # *
14 0001114E # * NEGF - SINGLE PRECISION FLOATING POINT LOAD_NEGATE TEST
15 0001114E # *
16 0001114E # *****************************************************************************/
17 0001114E # negf()
18 0001114E # {
19 0001114E 11 50 jbr L217
20 00011150 L218:
21 00011150 # asm(".globl _negf_t");
22 00011150 .globl _negf_t
23 00011150 # asm("_negf_t:"); /* entry address */
24 00011150 _negf_t:
25 00011150 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26 00011150 1d effffffff6 01 cmpl _cycle,$1
27 00011157 21 15 jneq L219
28 00011159 5d efffffffed tstl _prt_hdrs
29 0001115F 31 0d jeql L219
30 00011161 # writes(" NEGF");
31 00011161 .data 1
32 000008c8 * L221:
33 000008c8 * 204E45474600 .ascii " NEGF\0"
34 000008ce * .text
35 00011161 dd 8f000008c8 pushl $L221
36 00011167 fe 08 efffffffde callf $8,_writes
37 0001116E # negf_1(); /* negate through the cache */
38 0001116E L219:
39 0001116E fe 04 ef0000002d callf $4,_negf_1
40 00011175 # negf_2(); /* register stability */
41 00011175 fe 04 ef0000018a callf $4,_negf_2
42 0001117C # negf_3(); /* PSL stability test */
43 0001117C fe 04 ef00000323 callf $4,_negf_3
44 00011183 # if( !no_fpp_wcs ) {
45 00011183 5d efffffffc3 tstl _no_fpp_wcs
46 00011189 21 0e jneq L225
47 0001118B # negf_4(); /* pipelined entry test */
48 0001118B fe 04 ef000004c0 callf $4,_negf_4
49 00011192 # negf_5(); /* pipelined exit test */
50 00011192 fe 04 ef00000623 callf $4,_negf_5
51 00011199 # };
52 00011199 L225:
53 00011199 # asm("jmp *return"); /* return to the test monitor */
54 00011199 71 ffffffffad jmp *return
55 0001119F # }
56 0001119F 40 ret#2
57 000111A0 .set L215,0x0
58 000111A0 L217:
59 000111A0 11 ae jbr L218
60 000111A2 .data
61 000008c8 * .text
62 000111A2 .align 1
63 000111A2 .globl _negf_1
64 000111A2 _negf_1:
65 000111A2 0000 .word L228
66 000111A4 #
67 000111A4 #
68 000111A4 #
69 000111A4 # /************************************************************************
70 000111A4 # *
71 000111A4 # * SUBTEST 1 - negate through memory
72 000111A4 # *
73 000111A4 # ************************************************************************/
74 000111A4 # negf_1()
75 000111A4 # {
76 000111A4 13 015c jbr L230
77 000111A7 L231:
78 000111A7 # force_loop = FALSE;
79 000111A7 4d efffffff9f clrl _force_loop
80 000111AD # subtest = 1;
81 000111AD 0d 01 efffffff98 movl $1,_subtest
82 000111B4 # for( index = 0; index < max_lnf_1_index; index++ ) {
83 000111B4 4d efffffff92 clrl _index
84 000111BA L234:
85 000111BA 1d efffffff8c efffffff87 cmpl _index,_max_lnf_1_index
86 000111C5 91 03 13 0138 jgeq L233
87 000111CA # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
88 000111CA 0d efffffff7c 50 movl _index,r0
89 000111D1 48 03 50 50 shll $3,r0,r0
90 000111D5 0d e000000000 efffffff6c movl _lnf_1_data(r0),_sgl_ld_acc
91 000111E0 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
92 000111E0 0d efffffff66 50 movl _index,r0
93 000111E7 48 03 50 50 shll $3,r0,r0
94 000111EB 0d e000000004 efffffff56 movl _lnf_1_data+4(r0),_sgl_expected
95 000111F6 # /*
96 000111F6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
97 000111F6 # * The force loop flag is set after the first error.
98 000111F6 # */
99 000111F6 # asm("_negf_1_lp1:");
100 000111F6 _negf_1_lp1:
101 000111F6 # asm("ldf _sgl_ld_acc"); /* load the value */
102 000111F6 06 efffffff50 ldf _sgl_ld_acc
103 000111FC # asm("negf"); /* negate the value */
104 000111FC b6 negf
105 000111FD # asm("stf _sgl_st_acc"); /* store the result */
106 000111FD 26 efffffff49 stf _sgl_st_acc
107 00011203 # if( force_loop )
108 00011203 5d efffffff43 tstl _force_loop
109 00011209 31 02 jeql L235
110 0001120B # asm("brb _negf_1_lp1");; /* loop on the error */
111 0001120B 11 e9 brb _negf_1_lp1
112 0001120D L235:
113 0001120D # /*
114 0001120D # * end error loop - test the results
115 0001120D # */
116 0001120D # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
117 0001120D 1d efffffff39 efffffff34 cmpl _sgl_st_acc,_sgl_expected
118 00011218 21 03 13 00dc jeql L236
119 0001121D # errcnt++; /* bump the error count */
120 0001121D 6d efffffff29 incl _errcnt
121 00011223 # if( prt_error ) {
122 00011223 5d efffffff23 tstl _prt_error
123 00011229 21 03 13 00a8 jeql L237
124 0001122E # writes(" \n"); /* start a new print line */
125 0001122E .data 1
126 000008ce * L238:
127 000008ce * 200A00 .ascii " \12\0"
128 000008d1 * .text
129 0001122E dd 8f000008ce pushl $L238
130 00011234 fe 08 efffffff11 callf $8,_writes
131 0001123B # writes("cycle: ");
132 0001123B .data 1
133 000008d1 * L239:
134 000008d1 * 6379636C653A2000 .ascii "cycle: \0"
135 000008d9 * .text
136 0001123B dd 8f000008d1 pushl $L239
137 00011241 fe 08 efffffff04 callf $8,_writes
138 00011248 # writed( cycle );
139 00011248 dd effffffefe pushl _cycle
140 0001124E fe 08 effffffef7 callf $8,_writed
141 00011255 # writes(" NEGF test ");
142 00011255 .data 1
143 000008d9 * L241:
144 000008d9 * 20204E4547462074657374200 .ascii " NEGF test \0"
0
145 000008e6 * .text
146 00011255 dd 8f000008d9 pushl $L241
147 0001125B fe 08 effffffeea callf $8,_writes
148 00011262 # writed( test_no );
149 00011262 dd effffffee4 pushl _test_no
150 00011268 fe 08 effffffedd callf $8,_writed
151 0001126F # writes(", subtest 1 (Cache Data) - BAD FINAL ACC\n");
152 0001126F .data 1
153 000008e6 * L242:
154 000008e6 * 2C20737562746573742031202 .ascii ", subtest 1 (Cache Data) - BAD FINAL ACC\12\0"
8436163686520446174612920
2D204241442046494E414C204
143430A00
155 00000910 * .text
156 0001126F dd 8f000008e6 pushl $L242
157 00011275 fe 08 effffffed0 callf $8,_writes
158 0001127C # print_negf_data();
159 0001127C fe 04 ef000006a3 callf $4,_print_negf_data
160 00011283 # writes(", data index = ");
161 00011283 .data 1
162 00000910 * L244:
163 00000910 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
164 00000922 * .text
165 00011283 dd 8f00000910 pushl $L244
166 00011289 fe 08 effffffebc callf $8,_writes
167 00011290 # writed( index );
168 00011290 dd effffffeb6 pushl _index
169 00011296 fe 08 effffffeaf callf $8,_writed
170 0001129D # writec('\n');
171 0001129D dd 0a pushl $10
172 0001129F fe 08 effffffea6 callf $8,_writec
173 000112A6 # writes(" ");
174 000112A6 .data 1
175 00000922 * L246:
176 00000922 * 2020202020202020202020202 .ascii " \0"
020202020202020202000
177 00000939 * .text
178 000112A6 dd 8f00000922 pushl $L246
179 000112AC fe 08 effffffe99 callf $8,_writes
180 000112B3 # writes("Acc expected = ");
181 000112B3 .data 1
182 00000939 * L247:
183 00000939 * 4163632065787065637465642 .ascii "Acc expected = \0"
03D2000
184 00000949 * .text
185 000112B3 dd 8f00000939 pushl $L247
186 000112B9 fe 08 effffffe8c callf $8,_writes
187 000112C0 # write32h( sgl_expected );
188 000112C0 dd effffffe86 pushl _sgl_expected
189 000112C6 fe 08 effffffe7f callf $8,_write32h
190 000112CD # writec('\n');
191 000112CD dd 0a pushl $10
192 000112CF fe 08 effffffe76 callf $8,_writec
193 000112D6 # }
194 000112D6 # if( halt_flg )
195 000112D6 L237:
196 000112D6 5d effffffe70 tstl _halt_flg
197 000112DC 31 09 jeql L249
198 000112DE # negf_er_halt( BAD_ACC_HLT ); /* halt on the error */
199 000112DE dd 01 pushl $1
200 000112E0 fe 08 ef0000067b callf $8,_negf_er_halt
201 000112E7 # if( loop_on_err ) {
202 000112E7 L249:
203 000112E7 5d effffffe5f tstl _loop_on_err
204 000112ED 31 0a jeql L251
205 000112EF # force_loop = TRUE; /* set the force loop flag */
206 000112EF 0d 01 effffffe56 movl $1,_force_loop
207 000112F6 # asm("brw _negf_1_lp1");; /* and loop on the error */
208 000112F6 13 fefd brw _negf_1_lp1
209 000112F9 # } /* end of loop on error */
210 000112F9 # } /* end of compare error */
211 000112F9 L251:
212 000112F9 # } /* end of WHILE loop */
213 000112F9 L236:
214 000112F9 L232:
215 000112F9 6d effffffe4d incl _index
216 000112FF 13 feb8 jbr L234
217 00011302 L233:
218 00011302 # } /* end of subtest 1 */
219 00011302 40 ret#2
220 00011303 .set L228,0x0
221 00011303 L230:
222 00011303 13 fea1 jbr L231
223 00011306 .data
224 000008c8 * .text
225 00011306 .align 1
226 00011306 .globl _negf_2
227 00011306 _negf_2:
228 00011306 0000 .word L252
229 00011308 #
230 00011308 #
231 00011308 #
232 00011308 # /************************************************************************
233 00011308 # *
234 00011308 # * SUBTEST 2 - Check for register corruption
235 00011308 # *
236 00011308 # ************************************************************************/
237 00011308 # negf_2()
238 00011308 # {
239 00011308 13 0197 jbr L254
240 0001130B L255:
241 0001130B # force_loop = FALSE; /* clear force_loop flg */
242 0001130B 4d effffffe3b clrl _force_loop
243 00011311 # subtest = 2;
244 00011311 0d 02 effffffe34 movl $2,_subtest
245 00011318 # fill_reg_buf( load_regs ); /* get patterns for regs */
246 00011318 dd 8f00000000 pushl $_load_regs
247 0001131E fe 08 effffffe27 callf $8,_fill_reg_buf
248 00011325 # index = 0;
249 00011325 4d effffffe21 clrl _index
250 0001132B # sgl_ld_acc = lnf_1_data[0].ld; /* get value to negate */
251 0001132B 0d effffffe1b effffffe16 movl _lnf_1_data,_sgl_ld_acc
252 00011336 # sgl_expected = lnf_1_data[0].exp; /* get expected result */
253 00011336 0d effffffe14 effffffe0b movl _lnf_1_data+4,_sgl_expected
254 00011341 # /*
255 00011341 # * If LOOP ON ERROR is set, this is the loop for this subtest.
256 00011341 # * The force loop flag is set after the first error.
257 00011341 # */
258 00011341 # asm("_negf_2_lp1:");
259 00011341 _negf_2_lp1:
260 00011341 # asm("ldf _sgl_ld_acc"); /* load the initial value */
261 00011341 06 effffffe05 ldf _sgl_ld_acc
262 00011347 # asm("nop");
263 00011347 10 nop
264 00011348 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
265 00011348 ab 891fff effffffdfb loadr $0x1fff,_load_regs
266 00011351 # asm("nop");
267 00011351 10 nop
268 00011352 # asm("negf"); /* negate the value */
269 00011352 b6 negf
270 00011353 # asm("nop");
271 00011353 10 nop
272 00011354 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
273 00011354 bb 891fff effffffdef storer $0x1fff,_store_regs
274 0001135D # asm("stf _sgl_st_acc"); /* save the accumulator */
275 0001135D 26 effffffde9 stf _sgl_st_acc
276 00011363 # if( force_loop )
277 00011363 5d effffffde3 tstl _force_loop
278 00011369 31 02 jeql L257
279 0001136B # asm("brb _negf_2_lp1");; /* loop on the error */
280 0001136B 11 d4 brb _negf_2_lp1
281 0001136D L257:
282 0001136D # /*
283 0001136D # * Now compare the stored register values to those that were loaded
284 0001136D # */
285 0001136D # index2 = 0;
286 0001136D 4d effffffdd9 clrl _index2
287 00011373 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
288 00011373 L258:
289 00011373 0d effffffdd3 50 movl _index2,r0
290 0001137A 0d effffffdcc 51 movl _index2,r1
291 00011381 1d 40effffffdc4 cmpl _load_regs[r0],_store_regs[r1]
41effffffdbe
292 0001138E 21 11 jneq L259
293 00011390 1d effffffdb6 0d cmpl _index2,$13
294 00011397 81 08 jgeq L259
295 00011399 # index2++; /* check reg values */
296 00011399 6d effffffdad incl _index2
297 0001139F 11 d2 jbr L258
298 000113A1 L259:
299 000113A1 # if( index2 < 13 ) { /* error if index2 < 13 */
300 000113A1 1d effffffda5 0d cmpl _index2,$13
301 000113A8 91 03 13 00f4 jgeq L260
302 000113AD # errcnt++; /* bump the error count */
303 000113AD 6d effffffd99 incl _errcnt
304 000113B3 # if( prt_error ) {
305 000113B3 5d effffffd93 tstl _prt_error
306 000113B9 21 03 13 00c0 jeql L261
307 000113BE # writes(" \n"); /* start a new print line */
308 000113BE .data 1
309 00000949 * L262:
310 00000949 * 200A00 .ascii " \12\0"
311 0000094c * .text
312 000113BE dd 8f00000949 pushl $L262
313 000113C4 fe 08 effffffd81 callf $8,_writes
314 000113CB # writes("cycle: ");
315 000113CB .data 1
316 0000094c * L263:
317 0000094c * 6379636C653A2000 .ascii "cycle: \0"
318 00000954 * .text
319 000113CB dd 8f0000094c pushl $L263
320 000113D1 fe 08 effffffd74 callf $8,_writes
321 000113D8 # writed( cycle );
322 000113D8 dd effffffd6e pushl _cycle
323 000113DE fe 08 effffffd67 callf $8,_writed
324 000113E5 # writes(" NEGF test ");
325 000113E5 .data 1
326 00000954 * L264:
327 00000954 * 20204E4547462074657374200 .ascii " NEGF test \0"
0
328 00000961 * .text
329 000113E5 dd 8f00000954 pushl $L264
330 000113EB fe 08 effffffd5a callf $8,_writes
331 000113F2 # writed( test_no );
332 000113F2 dd effffffd54 pushl _test_no
333 000113F8 fe 08 effffffd4d callf $8,_writed
334 000113FF # writes(", subtest 2 (Reg. Corr.) - A REGISTER WAS MODIFIED\n");
335 000113FF .data 1
336 00000961 * L265:
337 00000961 * 2C20737562746573742032202 .ascii ", subtest 2 (Reg. Corr.) - A REGISTER WAS MODIFIED\12\0"
85265672E20436F72722E2920
2D20412052454749535445522
0574153204D4F444946494544
0A00
338 00000995 * .text
339 000113FF dd 8f00000961 pushl $L265
340 00011405 fe 08 effffffd40 callf $8,_writes
341 0001140C # print_negf_data(); /* print the operands */
342 0001140C fe 04 ef00000513 callf $4,_print_negf_data
343 00011413 # writes("\nregister "); /* print the information */
344 00011413 .data 1
345 00000995 * L266:
346 00000995 * 0A72656769737465722000 .ascii "\12register \0"
347 000009a0 * .text
348 00011413 dd 8f00000995 pushl $L266
349 00011419 fe 08 effffffd2c callf $8,_writes
350 00011420 # writed( index2 ); /* about the corrupted */
351 00011420 dd effffffd26 pushl _index2
352 00011426 fe 08 effffffd1f callf $8,_writed
353 0001142D # writes(" = "); /* register */
354 0001142D .data 1
355 000009a0 * L267:
356 000009a0 * 203D2000 .ascii " = \0"
357 000009a4 * .text
358 0001142D dd 8f000009a0 pushl $L267
359 00011433 fe 08 effffffd12 callf $8,_writes
360 0001143A # write32h( store_regs[index2] );
361 0001143A 0d effffffd0c 50 movl _index2,r0
362 00011441 dd 40effffffd04 pushl _store_regs[r0]
363 00011448 fe 08 effffffcfd callf $8,_write32h
364 0001144F # writes(", should be = ");
365 0001144F .data 1
366 000009a4 * L268:
367 000009a4 * 2C202073686F756C642062652 .ascii ", should be = \0"
03D2000
368 000009b4 * .text
369 0001144F dd 8f000009a4 pushl $L268
370 00011455 fe 08 effffffcf0 callf $8,_writes
371 0001145C # write32h( load_regs[index2] );
372 0001145C 0d effffffcea 50 movl _index2,r0
373 00011463 dd 40effffffce2 pushl _load_regs[r0]
374 0001146A fe 08 effffffcdb callf $8,_write32h
375 00011471 # writes("\n");
376 00011471 .data 1
377 000009b4 * L269:
378 000009b4 * 0A00 .ascii "\12\0"
379 000009b6 * .text
380 00011471 dd 8f000009b4 pushl $L269
381 00011477 fe 08 effffffcce callf $8,_writes
382 0001147E # }
383 0001147E # if( halt_flg )
384 0001147E L261:
385 0001147E 5d effffffcc8 tstl _halt_flg
386 00011484 31 09 jeql L270
387 00011486 # negf_er_halt( BAD_REG_HLT ); /* halt on the error */
388 00011486 dd 02 pushl $2
389 00011488 fe 08 ef000004d3 callf $8,_negf_er_halt
390 0001148F # if( loop_on_err ) {
391 0001148F L270:
392 0001148F 5d effffffcb7 tstl _loop_on_err
393 00011495 31 0a jeql L271
394 00011497 # force_loop = TRUE; /* set the force loop flag */
395 00011497 0d 01 effffffcae movl $1,_force_loop
396 0001149E # asm("brw _negf_2_lp1");; /* and loop on the error */
397 0001149E 13 fea0 brw _negf_2_lp1
398 000114A1 # } /* end of loop on error */
399 000114A1 # } /* end of register corruption error */
400 000114A1 L271:
401 000114A1 # } /* end of subtest 2 */
402 000114A1 L260:
403 000114A1 40 ret#2
404 000114A2 .set L252,0x0
405 000114A2 L254:
406 000114A2 13 fe66 jbr L255
407 000114A5 .data
408 000008c8 * .text
409 000114A5 00 .align 1
410 000114A6 .globl _negf_3
411 000114A6 _negf_3:
412 000114A6 0000 .word L272
413 000114A8 #
414 000114A8 #
415 000114A8 #
416 000114A8 # /************************************************************************
417 000114A8 # *
418 000114A8 # * SUBTEST 3 - Check for PSL corruption
419 000114A8 # *
420 000114A8 # ************************************************************************/
421 000114A8 # negf_3()
422 000114A8 # {
423 000114A8 13 01a4 jbr L274
424 000114AB L275:
425 000114AB # force_loop = FALSE; /* clear force_loop flg */
426 000114AB 4d effffffc9b clrl _force_loop
427 000114B1 # subtest = 3;
428 000114B1 0d 03 effffffc94 movl $3,_subtest
429 000114B8 # fill_reg_buf( load_regs ); /* get patterns for regs */
430 000114B8 dd 8f00000000 pushl $_load_regs
431 000114BE fe 08 effffffc87 callf $8,_fill_reg_buf
432 000114C5 # for( index = 0; index < 3; index++ ) {
433 000114C5 4d effffffc81 clrl _index
434 000114CB L278:
435 000114CB 1d effffffc7b 03 cmpl _index,$3
436 000114D2 91 03 13 0177 jgeq L277
437 000114D7 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
438 000114D7 0d effffffc6f 50 movl _index,r0
439 000114DE 48 03 50 50 shll $3,r0,r0
440 000114E2 0d e000000000 effffffc5f movl _lnf_1_data(r0),_sgl_ld_acc
441 000114ED # sgl_expected = lnf_1_data[index].exp; /* get expected */
442 000114ED 0d effffffc59 50 movl _index,r0
443 000114F4 48 03 50 50 shll $3,r0,r0
444 000114F8 0d e000000004 effffffc49 movl _lnf_1_data+4(r0),_sgl_expected
445 00011503 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
446 00011503 0d effffffc43 50 movl _status_index,r0
447 0001150A 0d 40effffffc3b movl _status_array[r0],_sgl_dummy1
effffffc36
448 00011516 # /*
449 00011516 # * If LOOP ON ERROR is set, this is the loop for this subtest.
450 00011516 # * The force loop flag is set after the first error.
451 00011516 # */
452 00011516 # asm("_negf_3_lp1:");
453 00011516 _negf_3_lp1:
454 00011516 # asm("ldf _sgl_ld_acc"); /* load the initial value */
455 00011516 06 effffffc30 ldf _sgl_ld_acc
456 0001151C # asm("nop");
457 0001151C 10 nop
458 0001151D # asm("tstl _sgl_dummy1"); /* set the PSL status */
459 0001151D 5d effffffc29 tstl _sgl_dummy1
460 00011523 # asm("movpsl _init_psl"); /* save the initial PSL */
461 00011523 cd effffffc23 movpsl _init_psl
462 00011529 # asm("negf"); /* negate the value */
463 00011529 b6 negf
464 0001152A # asm("nop");
465 0001152A 10 nop
466 0001152B # asm("movpsl _psl_val"); /* save the final PSL */
467 0001152B cd effffffc1b movpsl _psl_val
468 00011531 # asm("stf _sgl_st_acc"); /* save the accumulator */
469 00011531 26 effffffc15 stf _sgl_st_acc
470 00011537 # if( force_loop )
471 00011537 5d effffffc0f tstl _force_loop
472 0001153D 31 02 jeql L279
473 0001153F # asm("brb _negf_3_lp1");; /* loop on the error */
474 0001153F 11 d5 brb _negf_3_lp1
475 00011541 L279:
476 00011541 # /*
477 00011541 # * Now compare the final PSL to the initial PSL -they should be the same
478 00011541 # */
479 00011541 # exp_psl = init_psl;
480 00011541 0d effffffc05 effffffc00 movl _init_psl,_exp_psl
481 0001154C # if( psl_val != init_psl ) {
482 0001154C 1d effffffbfa effffffbf5 cmpl _psl_val,_init_psl
483 00011557 21 03 13 00e9 jeql L280
484 0001155C # errcnt++; /* bump the error count */
485 0001155C 6d effffffbea incl _errcnt
486 00011562 # if( prt_error ) {
487 00011562 5d effffffbe4 tstl _prt_error
488 00011568 21 03 13 00b5 jeql L281
489 0001156D # writes(" \n"); /* start a new print line */
490 0001156D .data 1
491 000009b6 * L282:
492 000009b6 * 200A00 .ascii " \12\0"
493 000009b9 * .text
494 0001156D dd 8f000009b6 pushl $L282
495 00011573 fe 08 effffffbd2 callf $8,_writes
496 0001157A # writes("cycle: ");
497 0001157A .data 1
498 000009b9 * L283:
499 000009b9 * 6379636C653A2000 .ascii "cycle: \0"
500 000009c1 * .text
501 0001157A dd 8f000009b9 pushl $L283
502 00011580 fe 08 effffffbc5 callf $8,_writes
503 00011587 # writed( cycle );
504 00011587 dd effffffbbf pushl _cycle
505 0001158D fe 08 effffffbb8 callf $8,_writed
506 00011594 # writes(" NEGF test ");
507 00011594 .data 1
508 000009c1 * L284:
509 000009c1 * 20204E4547462074657374200 .ascii " NEGF test \0"
0
510 000009ce * .text
511 00011594 dd 8f000009c1 pushl $L284
512 0001159A fe 08 effffffbab callf $8,_writes
513 000115A1 # writed( test_no );
514 000115A1 dd effffffba5 pushl _test_no
515 000115A7 fe 08 effffffb9e callf $8,_writed
516 000115AE # writes(", subtest 3 (PSL Corr.) - INCORRECT FINAL PSL\n");
517 000115AE .data 1
518 000009ce * L285:
519 000009ce * 2C20737562746573742033202 .ascii ", subtest 3 (PSL Corr.) - INCORRECT FINAL PSL\12\0"
850534C20436F72722E29202D
20494E434F525245435420464
94E414C2050534C0A00
520 000009fd * .text
521 000115AE dd 8f000009ce pushl $L285
522 000115B4 fe 08 effffffb91 callf $8,_writes
523 000115BB # print_negf_data(); /* print the operands */
524 000115BB fe 04 ef00000364 callf $4,_print_negf_data
525 000115C2 # writec('\n');
526 000115C2 dd 0a pushl $10
527 000115C4 fe 08 effffffb81 callf $8,_writec
528 000115CB # writes("initial PSL = ");
529 000115CB .data 1
530 000009fd * L286:
531 000009fd * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
532 00000a0c * .text
533 000115CB dd 8f000009fd pushl $L286
534 000115D1 fe 08 effffffb74 callf $8,_writes
535 000115D8 # write32h( init_psl );
536 000115D8 dd effffffb6e pushl _init_psl
537 000115DE fe 08 effffffb67 callf $8,_write32h
538 000115E5 # writes(", final PSL = ");
539 000115E5 .data 1
540 00000a0c * L287:
541 00000a0c * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
542 00000a1c * .text
543 000115E5 dd 8f00000a0c pushl $L287
544 000115EB fe 08 effffffb5a callf $8,_writes
545 000115F2 # write32h( psl_val );
546 000115F2 dd effffffb54 pushl _psl_val
547 000115F8 fe 08 effffffb4d callf $8,_write32h
548 000115FF # writes(", expected PSL = ");
549 000115FF .data 1
550 00000a1c * L288:
551 00000a1c * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
552 00000a2f * .text
553 000115FF dd 8f00000a1c pushl $L288
554 00011605 fe 08 effffffb40 callf $8,_writes
555 0001160C # write32h( exp_psl );
556 0001160C dd effffffb3a pushl _exp_psl
557 00011612 fe 08 effffffb33 callf $8,_write32h
558 00011619 # writec('\n');
559 00011619 dd 0a pushl $10
560 0001161B fe 08 effffffb2a callf $8,_writec
561 00011622 # }
562 00011622 # if( halt_flg )
563 00011622 L281:
564 00011622 5d effffffb24 tstl _halt_flg
565 00011628 31 09 jeql L289
566 0001162A # negf_er_halt( BAD_PSL_HLT ); /* halt on the error */
567 0001162A dd 03 pushl $3
568 0001162C fe 08 ef0000032f callf $8,_negf_er_halt
569 00011633 # if( loop_on_err ) {
570 00011633 L289:
571 00011633 5d effffffb13 tstl _loop_on_err
572 00011639 31 0a jeql L290
573 0001163B # force_loop = TRUE; /* set the force loop flag */
574 0001163B 0d 01 effffffb0a movl $1,_force_loop
575 00011642 # asm("brw _negf_3_lp1");; /* and loop on the error */
576 00011642 13 fed1 brw _negf_3_lp1
577 00011645 # } /* end of loop on error */
578 00011645 # } /* end of PSL corruption error */
579 00011645 L290:
580 00011645 # } /* end of WHILE loop */
581 00011645 L280:
582 00011645 L276:
583 00011645 6d effffffb01 incl _index
584 0001164B 13 fe7d jbr L278
585 0001164E L277:
586 0001164E # } /* end of subtest 3 */
587 0001164E 40 ret#2
588 0001164F .set L272,0x0
589 0001164F L274:
590 0001164F 13 fe59 jbr L275
591 00011652 .data
592 000008c8 * .text
593 00011652 .align 1
594 00011652 .globl _negf_4
595 00011652 _negf_4:
596 00011652 0000 .word L291
597 00011654 #
598 00011654 #
599 00011654 #
600 00011654 # /************************************************************************
601 00011654 # *
602 00011654 # * SUBTEST 4 - pipelined entry test
603 00011654 # *
604 00011654 # ************************************************************************/
605 00011654 # negf_4()
606 00011654 # {
607 00011654 13 0161 jbr L293
608 00011657 L294:
609 00011657 # force_loop = FALSE;
610 00011657 4d effffffaef clrl _force_loop
611 0001165D # subtest = 4;
612 0001165D 0d 04 effffffae8 movl $4,_subtest
613 00011664 # for( index = 0; index < max_lnf_1_index; index++ ) {
614 00011664 4d effffffae2 clrl _index
615 0001166A L297:
616 0001166A 1d effffffadc effffffad7 cmpl _index,_max_lnf_1_index
617 00011675 91 03 13 013d jgeq L296
618 0001167A # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
619 0001167A 0d effffffacc 50 movl _index,r0
620 00011681 48 03 50 50 shll $3,r0,r0
621 00011685 0d e000000000 effffffabc movl _lnf_1_data(r0),_sgl_ld_acc
622 00011690 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
623 00011690 0d effffffab6 50 movl _index,r0
624 00011697 48 03 50 50 shll $3,r0,r0
625 0001169B 0d e000000004 effffffaa6 movl _lnf_1_data+4(r0),_sgl_expected
626 000116A6 # /*
627 000116A6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
628 000116A6 # * The force loop flag is set after the first error.
629 000116A6 # */
630 000116A6 # asm("_negf_4_lp1:");
631 000116A6 _negf_4_lp1:
632 000116A6 # asm("movl $0,r0"); /* clear r0 */
633 000116A6 0d 00 50 movl $0,r0
634 000116A9 # asm("ldf r0"); /* load the Acc. with 0.0 */
635 000116A9 06 50 ldf r0
636 000116AB # asm("addf _sgl_ld_acc"); /* add the value to negate */
637 000116AB c6 effffffa9b addf _sgl_ld_acc
638 000116B1 # asm("negf"); /* negate the value */
639 000116B1 b6 negf
640 000116B2 # asm("stf _sgl_st_acc"); /* store the result */
641 000116B2 26 effffffa94 stf _sgl_st_acc
642 000116B8 # if( force_loop )
643 000116B8 5d effffffa8e tstl _force_loop
644 000116BE 31 02 jeql L298
645 000116C0 # asm("brb _negf_4_lp1");; /* loop on the error */
646 000116C0 11 e4 brb _negf_4_lp1
647 000116C2 L298:
648 000116C2 # /*
649 000116C2 # * end error loop - test the results
650 000116C2 # */
651 000116C2 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
652 000116C2 1d effffffa84 effffffa7f cmpl _sgl_st_acc,_sgl_expected
653 000116CD 21 03 13 00dc jeql L299
654 000116D2 # errcnt++; /* bump the error count */
655 000116D2 6d effffffa74 incl _errcnt
656 000116D8 # if( prt_error ) {
657 000116D8 5d effffffa6e tstl _prt_error
658 000116DE 21 03 13 00a8 jeql L300
659 000116E3 # writes(" \n"); /* start a new print line */
660 000116E3 .data 1
661 00000a2f * L301:
662 00000a2f * 200A00 .ascii " \12\0"
663 00000a32 * .text
664 000116E3 dd 8f00000a2f pushl $L301
665 000116E9 fe 08 effffffa5c callf $8,_writes
666 000116F0 # writes("cycle: ");
667 000116F0 .data 1
668 00000a32 * L302:
669 00000a32 * 6379636C653A2000 .ascii "cycle: \0"
670 00000a3a * .text
671 000116F0 dd 8f00000a32 pushl $L302
672 000116F6 fe 08 effffffa4f callf $8,_writes
673 000116FD # writed( cycle );
674 000116FD dd effffffa49 pushl _cycle
675 00011703 fe 08 effffffa42 callf $8,_writed
676 0001170A # writes(" NEGF test ");
677 0001170A .data 1
678 00000a3a * L303:
679 00000a3a * 20204E4547462074657374200 .ascii " NEGF test \0"
0
680 00000a47 * .text
681 0001170A dd 8f00000a3a pushl $L303
682 00011710 fe 08 effffffa35 callf $8,_writes
683 00011717 # writed( test_no );
684 00011717 dd effffffa2f pushl _test_no
685 0001171D fe 08 effffffa28 callf $8,_writed
686 00011724 # writes(", subtest 4 (Piped Entry) - BAD FINAL ACC\n");
687 00011724 .data 1
688 00000a47 * L304:
689 00000a47 * 2C20737562746573742034202 .ascii ", subtest 4 (Piped Entry) - BAD FINAL ACC\12\0"
8506970656420456E74727929
202D204241442046494E414C2
04143430A00
690 00000a72 * .text
691 00011724 dd 8f00000a47 pushl $L304
692 0001172A fe 08 effffffa1b callf $8,_writes
693 00011731 # print_negf_data();
694 00011731 fe 04 ef000001ee callf $4,_print_negf_data
695 00011738 # writes(", data index = ");
696 00011738 .data 1
697 00000a72 * L305:
698 00000a72 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
699 00000a84 * .text
700 00011738 dd 8f00000a72 pushl $L305
701 0001173E fe 08 effffffa07 callf $8,_writes
702 00011745 # writed( index );
703 00011745 dd effffffa01 pushl _index
704 0001174B fe 08 effffff9fa callf $8,_writed
705 00011752 # writec('\n');
706 00011752 dd 0a pushl $10
707 00011754 fe 08 effffff9f1 callf $8,_writec
708 0001175B # writes(" ");
709 0001175B .data 1
710 00000a84 * L306:
711 00000a84 * 2020202020202020202020202 .ascii " \0"
020202020202020202000
712 00000a9b * .text
713 0001175B dd 8f00000a84 pushl $L306
714 00011761 fe 08 effffff9e4 callf $8,_writes
715 00011768 # writes("Acc expected = ");
716 00011768 .data 1
717 00000a9b * L307:
718 00000a9b * 4163632065787065637465642 .ascii "Acc expected = \0"
03D2000
719 00000aab * .text
720 00011768 dd 8f00000a9b pushl $L307
721 0001176E fe 08 effffff9d7 callf $8,_writes
722 00011775 # write32h( sgl_expected );
723 00011775 dd effffff9d1 pushl _sgl_expected
724 0001177B fe 08 effffff9ca callf $8,_write32h
725 00011782 # writec('\n');
726 00011782 dd 0a pushl $10
727 00011784 fe 08 effffff9c1 callf $8,_writec
728 0001178B # }
729 0001178B # if( halt_flg )
730 0001178B L300:
731 0001178B 5d effffff9bb tstl _halt_flg
732 00011791 31 09 jeql L308
733 00011793 # negf_er_halt( BAD_ACC_HLT ); /* halt on the error */
734 00011793 dd 01 pushl $1
735 00011795 fe 08 ef000001c6 callf $8,_negf_er_halt
736 0001179C # if( loop_on_err ) {
737 0001179C L308:
738 0001179C 5d effffff9aa tstl _loop_on_err
739 000117A2 31 0a jeql L309
740 000117A4 # force_loop = TRUE; /* set the force loop flag */
741 000117A4 0d 01 effffff9a1 movl $1,_force_loop
742 000117AB # asm("brw _negf_4_lp1");; /* and loop on the error */
743 000117AB 13 fef8 brw _negf_4_lp1
744 000117AE # } /* end of loop on error */
745 000117AE # } /* end of compare error */
746 000117AE L309:
747 000117AE # } /* end of WHILE loop */
748 000117AE L299:
749 000117AE L295:
750 000117AE 6d effffff998 incl _index
751 000117B4 13 feb3 jbr L297
752 000117B7 L296:
753 000117B7 # } /* end of subtest 4 */
754 000117B7 40 ret#2
755 000117B8 .set L291,0x0
756 000117B8 L293:
757 000117B8 13 fe9c jbr L294
758 000117BB .data
759 000008c8 * .text
760 000117BB 00 .align 1
761 000117BC .globl _negf_5
762 000117BC _negf_5:
763 000117BC 0000 .word L310
764 000117BE #
765 000117BE #
766 000117BE #
767 000117BE # /************************************************************************
768 000117BE # *
769 000117BE # * SUBTEST 5 - pipelined exit test
770 000117BE # *
771 000117BE # ************************************************************************/
772 000117BE # negf_5()
773 000117BE # {
774 000117BE 13 0161 jbr L312
775 000117C1 L313:
776 000117C1 # force_loop = FALSE;
777 000117C1 4d effffff985 clrl _force_loop
778 000117C7 # subtest = 5;
779 000117C7 0d 05 effffff97e movl $5,_subtest
780 000117CE # for( index = 0; index < max_lnf_1_index; index++ ) {
781 000117CE 4d effffff978 clrl _index
782 000117D4 L316:
783 000117D4 1d effffff972 effffff96d cmpl _index,_max_lnf_1_index
784 000117DF 91 03 13 013d jgeq L315
785 000117E4 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
786 000117E4 0d effffff962 50 movl _index,r0
787 000117EB 48 03 50 50 shll $3,r0,r0
788 000117EF 0d e000000000 effffff952 movl _lnf_1_data(r0),_sgl_ld_acc
789 000117FA # sgl_expected = lnf_1_data[index].exp; /* get expected result */
790 000117FA 0d effffff94c 50 movl _index,r0
791 00011801 48 03 50 50 shll $3,r0,r0
792 00011805 0d e000000004 effffff93c movl _lnf_1_data+4(r0),_sgl_expected
793 00011810 # /*
794 00011810 # * If LOOP ON ERROR is set, this is the loop for this subtest.
795 00011810 # * The force loop flag is set after the first error.
796 00011810 # */
797 00011810 # asm("_negf_5_lp1:");
798 00011810 _negf_5_lp1:
799 00011810 # asm("movl $0,r0"); /* clear r0 */
800 00011810 0d 00 50 movl $0,r0
801 00011813 # asm("ldf _sgl_ld_acc"); /* load the value */
802 00011813 06 effffff933 ldf _sgl_ld_acc
803 00011819 # asm("negf"); /* negate the value */
804 00011819 b6 negf
805 0001181A # asm("addf r0"); /* add a zero to the acc */
806 0001181A c6 50 addf r0
807 0001181C # asm("stf _sgl_st_acc"); /* store the result */
808 0001181C 26 effffff92a stf _sgl_st_acc
809 00011822 # if( force_loop )
810 00011822 5d effffff924 tstl _force_loop
811 00011828 31 02 jeql L317
812 0001182A # asm("brb _negf_5_lp1");; /* loop on the error */
813 0001182A 11 e4 brb _negf_5_lp1
814 0001182C L317:
815 0001182C # /*
816 0001182C # * end error loop - test the results
817 0001182C # */
818 0001182C # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
819 0001182C 1d effffff91a effffff915 cmpl _sgl_st_acc,_sgl_expected
820 00011837 21 03 13 00dc jeql L318
821 0001183C # errcnt++; /* bump the error count */
822 0001183C 6d effffff90a incl _errcnt
823 00011842 # if( prt_error ) {
824 00011842 5d effffff904 tstl _prt_error
825 00011848 21 03 13 00a8 jeql L319
826 0001184D # writes(" \n"); /* start a new print line */
827 0001184D .data 1
828 00000aab * L320:
829 00000aab * 200A00 .ascii " \12\0"
830 00000aae * .text
831 0001184D dd 8f00000aab pushl $L320
832 00011853 fe 08 effffff8f2 callf $8,_writes
833 0001185A # writes("cycle: ");
834 0001185A .data 1
835 00000aae * L321:
836 00000aae * 6379636C653A2000 .ascii "cycle: \0"
837 00000ab6 * .text
838 0001185A dd 8f00000aae pushl $L321
839 00011860 fe 08 effffff8e5 callf $8,_writes
840 00011867 # writed( cycle );
841 00011867 dd effffff8df pushl _cycle
842 0001186D fe 08 effffff8d8 callf $8,_writed
843 00011874 # writes(" NEGF test ");
844 00011874 .data 1
845 00000ab6 * L322:
846 00000ab6 * 20204E4547462074657374200 .ascii " NEGF test \0"
0
847 00000ac3 * .text
848 00011874 dd 8f00000ab6 pushl $L322
849 0001187A fe 08 effffff8cb callf $8,_writes
850 00011881 # writed( test_no );
851 00011881 dd effffff8c5 pushl _test_no
852 00011887 fe 08 effffff8be callf $8,_writed
853 0001188E # writes(", subtest 5 (Piped Exit) - BAD FINAL ACC\n");
854 0001188E .data 1
855 00000ac3 * L323:
856 00000ac3 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Exit) - BAD FINAL ACC\12\0"
8506970656420457869742920
2D204241442046494E414C204
143430A00
857 00000aed * .text
858 0001188E dd 8f00000ac3 pushl $L323
859 00011894 fe 08 effffff8b1 callf $8,_writes
860 0001189B # print_negf_data();
861 0001189B fe 04 ef00000084 callf $4,_print_negf_data
862 000118A2 # writes(", data index = ");
863 000118A2 .data 1
864 00000aed * L324:
865 00000aed * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
866 00000aff * .text
867 000118A2 dd 8f00000aed pushl $L324
868 000118A8 fe 08 effffff89d callf $8,_writes
869 000118AF # writed( index );
870 000118AF dd effffff897 pushl _index
871 000118B5 fe 08 effffff890 callf $8,_writed
872 000118BC # writec('\n');
873 000118BC dd 0a pushl $10
874 000118BE fe 08 effffff887 callf $8,_writec
875 000118C5 # writes(" ");
876 000118C5 .data 1
877 00000aff * L325:
878 00000aff * 2020202020202020202020202 .ascii " \0"
020202020202020202000
879 00000b16 * .text
880 000118C5 dd 8f00000aff pushl $L325
881 000118CB fe 08 effffff87a callf $8,_writes
882 000118D2 # writes("Acc expected = ");
883 000118D2 .data 1
884 00000b16 * L326:
885 00000b16 * 4163632065787065637465642 .ascii "Acc expected = \0"
03D2000
886 00000b26 * .text
887 000118D2 dd 8f00000b16 pushl $L326
888 000118D8 fe 08 effffff86d callf $8,_writes
889 000118DF # write32h( sgl_expected );
890 000118DF dd effffff867 pushl _sgl_expected
891 000118E5 fe 08 effffff860 callf $8,_write32h
892 000118EC # writec('\n');
893 000118EC dd 0a pushl $10
894 000118EE fe 08 effffff857 callf $8,_writec
895 000118F5 # }
896 000118F5 # if( halt_flg )
897 000118F5 L319:
898 000118F5 5d effffff851 tstl _halt_flg
899 000118FB 31 09 jeql L327
900 000118FD # negf_er_halt( BAD_ACC_HLT ); /* halt on the error */
901 000118FD dd 01 pushl $1
902 000118FF fe 08 ef0000005c callf $8,_negf_er_halt
903 00011906 # if( loop_on_err ) {
904 00011906 L327:
905 00011906 5d effffff840 tstl _loop_on_err
906 0001190C 31 0a jeql L328
907 0001190E # force_loop = TRUE; /* set the force loop flag */
908 0001190E 0d 01 effffff837 movl $1,_force_loop
909 00011915 # asm("brw _negf_5_lp1");; /* and loop on the error */
910 00011915 13 fef8 brw _negf_5_lp1
911 00011918 # } /* end of loop on error */
912 00011918 # } /* end of compare error */
913 00011918 L328:
914 00011918 # } /* end of WHILE loop */
915 00011918 L318:
916 00011918 L314:
917 00011918 6d effffff82e incl _index
918 0001191E 13 feb3 jbr L316
919 00011921 L315:
920 00011921 # } /* end of subtest 5 */
921 00011921 40 ret#2
922 00011922 .set L310,0x0
923 00011922 L312:
924 00011922 13 fe9c jbr L313
925 00011925 .data
926 000008c8 * .text
927 00011925 00 .align 1
928 00011926 .globl _print_negf_data
929 00011926 _print_negf_data:
930 00011926 0000 .word L329
931 00011928 #
932 00011928 #
933 00011928 #
934 00011928 # /**************************************************************************
935 00011928 # *
936 00011928 # * PRINT THE DATA AND STORE RESULTS
937 00011928 # *
938 00011928 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
939 00011928 # * expected = xxxxxxxx
940 00011928 # **************************************************************************/
941 00011928 # print_negf_data()
942 00011928 # {
943 00011928 11 35 jbr L331
944 0001192A L332:
945 0001192A # writes("initial Acc = ");
946 0001192A .data 1
947 00000b26 * L333:
948 00000b26 * 696E697469616C20416363203 .ascii "initial Acc = \0"
D2000
949 00000b35 * .text
950 0001192A dd 8f00000b26 pushl $L333
951 00011930 fe 08 effffff815 callf $8,_writes
952 00011937 # write32h( sgl_ld_acc );
953 00011937 dd effffff80f pushl _sgl_ld_acc
954 0001193D fe 08 effffff808 callf $8,_write32h
955 00011944 # writes(", final Acc = ");
956 00011944 .data 1
957 00000b35 * L334:
958 00000b35 * 2C202066696E616C204163632 .ascii ", final Acc = \0"
03D2000
959 00000b45 * .text
960 00011944 dd 8f00000b35 pushl $L334
961 0001194A fe 08 effffff7fb callf $8,_writes
962 00011951 # write32h( sgl_st_acc );
963 00011951 dd effffff7f5 pushl _sgl_st_acc
964 00011957 fe 08 effffff7ee callf $8,_write32h
965 0001195E # }
966 0001195E 40 ret#2
967 0001195F .set L329,0x0
968 0001195F L331:
969 0001195F 11 c9 jbr L332
970 00011961 .data
971 000008c8 * .text
972 00011961 00 .align 1
973 00011962 .globl _negf_er_halt
974 00011962 _negf_er_halt:
975 00011962 0000 .word L335
976 00011964 #
977 00011964 #
978 00011964 #
979 00011964 # /**************************************************************************
980 00011964 # *
981 00011964 # * HALT ON ERROR ROUTINE
982 00011964 # *
983 00011964 # **************************************************************************/
984 00011964 # negf_er_halt( halt_code )
985 00011964 # int halt_code;
986 00011964 # {
987 00011964 13 00a8 jbr L337
988 00011967 L338:
989 00011967 # sgl_dummy1 = halt_code; /* get the error type */
990 00011967 0d ad04 effffff7dd movl 4(fp),_sgl_dummy1
991 0001196F # asm("movl _test_no,r0"); /* r0 = test number */
992 0001196F 0d effffff7d7 50 movl _test_no,r0
993 00011976 # asm("movl _subtest,r1"); /* r1 = subtest number */
994 00011976 0d effffff7d0 51 movl _subtest,r1
995 0001197D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
996 0001197D 0d effffff7c9 52 movl _sgl_dummy1,r2
997 00011984 # asm("movl _cycle,r3"); /* r3 = cycle count */
998 00011984 0d effffff7c2 53 movl _cycle,r3
999 0001198B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1000 0001198B 0d effffff7bb 54 movl _sgl_ld_acc,r4
1001 00011992 # asm("movl _sgl_value_1,r5"); /* r5 = data loaded */
1002 00011992 0d effffff7b4 55 movl _sgl_value_1,r5
1003 00011999 # if( halt_code == BAD_ACC_HLT ) {
1004 00011999 1d ad04 01 cmpl 4(fp),$1
1005 0001199D 21 10 jneq L339
1006 0001199F # asm("movl _sgl_st_acc,r6"); /* r6 = data stored */
1007 0001199F 0d effffff7a7 56 movl _sgl_st_acc,r6
1008 000119A6 # asm("movl _sgl_expected,r7"); /* r7 = data expected */
1009 000119A6 0d effffff7a0 57 movl _sgl_expected,r7
1010 000119AD # } else
1011 000119AD 11 5e jbr L340
1012 000119AF L339:
1013 000119AF # if( halt_code == BAD_REG_HLT ) {
1014 000119AF 1d ad04 02 cmpl 4(fp),$2
1015 000119B3 21 3d jneq L341
1016 000119B5 # sgl_dummy1 = load_regs[index2];
1017 000119B5 0d effffff791 50 movl _index2,r0
1018 000119BC 0d 40effffff789 movl _load_regs[r0],_sgl_dummy1
effffff784
1019 000119C8 # sgl_dummy2 = store_regs[index2];
1020 000119C8 0d effffff77e 50 movl _index2,r0
1021 000119CF 0d 40effffff776 movl _store_regs[r0],_sgl_dummy2
effffff771
1022 000119DB # asm("movl _index2,r6"); /* r6 = bad register # */
1023 000119DB 0d effffff76b 56 movl _index2,r6
1024 000119E2 # asm("movl _sgl_dummy1,r7"); /* r7 = actual value */
1025 000119E2 0d effffff764 57 movl _sgl_dummy1,r7
1026 000119E9 # asm("movl _sgl_dummy2,r8"); /* r8 = expected value */
1027 000119E9 0d effffff75d 58 movl _sgl_dummy2,r8
1028 000119F0 # } else
1029 000119F0 11 1b jbr L342
1030 000119F2 L341:
1031 000119F2 # if( halt_code == BAD_PSL_HLT ) {
1032 000119F2 1d ad04 03 cmpl 4(fp),$3
1033 000119F6 21 15 jneq L343
1034 000119F8 # asm("movl _init_psl,r6"); /* r6 = initial PSL */
1035 000119F8 0d effffff74e 56 movl _init_psl,r6
1036 000119FF # asm("movl _psl_val,r7"); /* r7 = final PSL */
1037 000119FF 0d effffff747 57 movl _psl_val,r7
1038 00011A06 # asm("movl _exp_psl,r8"); /* r8 = expected PSL */
1039 00011A06 0d effffff740 58 movl _exp_psl,r8
1040 00011A0D # };
1041 00011A0D L343:
1042 00011A0D L342:
1043 00011A0D L340:
1044 00011A0D # asm("halt"); /* HALT ... */
1045 00011A0D 00 halt
1046 00011A0E # }
1047 00011A0E 40 ret#2
1048 00011A0F .set L335,0x0
1049 00011A0F L337:
1050 00011A0F 13 ff55 jbr L338
1051 00011A12 .data
1051 00022B5E .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.