![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cosf.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 cosf.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 00000a58 * .text
4 00000000 .align 1
5 00000000 .globl _cosf
6 00000000 _cosf:
7 00022A78 0000 .word L215
8 00022A7A # #include "fpp_defs.h"
9 00022A7A #
10 00022A7A #
11 00022A7A #
12 00022A7A # /***************************************************************************
13 00022A7A # *
14 00022A7A # * COSF - SINGLE PRECISION FLOATING POINT COSF FUNCTION TEST
15 00022A7A # *
16 00022A7A # * COSF TEST MONITOR
17 00022A7A # *
18 00022A7A # *****************************************************************************/
19 00022A7A # cosf()
20 00022A7A # {
21 00022A7A 11 48 jbr L217
22 00022A7C L218:
23 00022A7C # asm(".globl _cosf_t");
24 00022A7C .globl _cosf_t
25 00022A7C # asm("_cosf_t:"); /* entry address */
26 00022A7C _cosf_t:
27 00022A7C # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
28 00022A7C 1d effffffff6 01 cmpl _cycle,$1
29 00022A83 21 15 jneq L219
30 00022A85 5d efffffffed tstl _prt_hdrs
31 00022A8B 31 0d jeql L219
32 00022A8D # {
33 00022A8D # writes(" COSF");
34 00022A8D .data 1
35 00000a58 * L221:
36 00000a58 * 20434F534600 .ascii " COSF\0"
37 00000a5e * .text
38 00022A8D dd 8f00000a58 pushl $L221
39 00022A93 fe 08 efffffffde callf $8,_writes
40 00022A9A # }
41 00022A9A # cosf_1(); /* test square root w/ delay */
42 00022A9A L219:
43 00022A9A fe 04 ef00000025 callf $4,_cosf_1
44 00022AA1 # cosf_2(); /* test square root */
45 00022AA1 fe 04 ef00000190 callf $4,_cosf_2
46 00022AA8 # cosf_3(); /* register corruption */
47 00022AA8 fe 04 ef000002e9 callf $4,_cosf_3
48 00022AAF # /* cosf_4(); /* test the PSL */
49 00022AAF # cosf_5(); /* pipelined entry */
50 00022AAF fe 04 ef0000067c callf $4,_cosf_5
51 00022AB6 # cosf_6(); /* pipelined exit */
52 00022AB6 fe 04 ef000007d1 callf $4,_cosf_6
53 00022ABD # asm("jmp *return"); /* return to the test monitor */
54 00022ABD 71 ffffffffb5 jmp *return
55 00022AC3 # }
56 00022AC3 40 ret#2
57 00022AC4 .set L215,0x0
58 00022AC4 L217:
59 00022AC4 11 b6 jbr L218
60 00022AC6 .data
61 00000a58 * .text
62 00022AC6 .align 1
63 00022AC6 .globl _cosf_1
64 00022AC6 _cosf_1:
65 00022AC6 0000 .word L227
66 00022AC8 #
67 00022AC8 # /***************************************************************************
68 00022AC8 # *
69 00022AC8 # * SUBTEST 1 - COSF FUNCTION
70 00022AC8 # *
71 00022AC8 # ***************************************************************************/
72 00022AC8 # cosf_1()
73 00022AC8 # {
74 00022AC8 13 016a jbr L229
75 00022ACB L230:
76 00022ACB # #define DELAY 20 /* wait 40 ticks between COSF and STF */
77 00022ACB # force_loop = FALSE; /* clear the LOOP flag */
78 00022ACB 4d efffffffa7 clrl _force_loop
79 00022AD1 # subtest = 1;
80 00022AD1 0d 01 efffffffa0 movl $1,_subtest
81 00022AD8 # index = 0;
82 00022AD8 4d efffffff9a clrl _index
83 00022ADE # do
84 00022ADE L233:
85 00022ADE # {
86 00022ADE # sgl_ld_acc = cosf_1_data[index].ld; /* get the operand */
87 00022ADE 0d efffffff94 50 movl _index,r0
88 00022AE5 48 03 50 50 shll $3,r0,r0
89 00022AE9 0d e000000000 efffffff84 movl _cosf_1_data(r0),_sgl_ld_acc
90 00022AF4 # sgl_expected = cosf_1_data[index].exp; /* get expected results */
91 00022AF4 0d efffffff7e 50 movl _index,r0
92 00022AFB 48 03 50 50 shll $3,r0,r0
93 00022AFF 0d e000000004 efffffff6e movl _cosf_1_data+4(r0),_sgl_expected
94 00022B0A # sgl_dummy1 = DELAY;
95 00022B0A 0d 14 efffffff67 movl $20,_sgl_dummy1
96 00022B11 # /*
97 00022B11 # * If LOOP ON ERROR is set, this is the loop for this subtest.
98 00022B11 # * The force loop flag is set after the first error.
99 00022B11 # */
100 00022B11 # asm("_cosf_1_lp1:");
101 00022B11 _cosf_1_lp1:
102 00022B11 # asm("movl _sgl_ld_acc,r4"); /* set the data to load */
103 00022B11 0d efffffff61 54 movl _sgl_ld_acc,r4
104 00022B18 # asm("ldf r4"); /* load the accumulator */
105 00022B18 06 54 ldf r4
106 00022B1A # asm("movl _sgl_dummy1,r0"); /* get the delay factor */
107 00022B1A 0d efffffff58 50 movl _sgl_dummy1,r0
108 00022B21 # asm("cosf"); /* get ACC.'s cosine */
109 00022B21 15 cosf
110 00022B22 # asm("1:");
111 00022B22 1:
112 00022B22 # asm("decl r0"); /* delay to let the COSF */
113 00022B22 7d 50 decl r0
114 00022B24 # asm("bgtr 1b"); /* instruction finish */
115 00022B24 41 fc bgtr 1b
116 00022B26 # asm("stf r5"); /* store the result */
117 00022B26 26 55 stf r5
118 00022B28 # if( force_loop )
119 00022B28 5d efffffff4a tstl _force_loop
120 00022B2E 31 02 jeql L234
121 00022B30 # asm("brb _cosf_1_lp1");; /* loop on the error */
122 00022B30 11 df brb _cosf_1_lp1
123 00022B32 L234:
124 00022B32 # /*
125 00022B32 # * end error loop
126 00022B32 # */
127 00022B32 # asm("movl r5,_sgl_st_acc"); /* save the result */
128 00022B32 0d 55 efffffff3f movl r5,_sgl_st_acc
129 00022B39 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
130 00022B39 1d efffffff39 efffffff34 cmpl _sgl_st_acc,_sgl_expected
131 00022B44 21 03 13 00d2 jeql L235
132 00022B49 # {
133 00022B49 # errcnt++; /* bump the error count */
134 00022B49 6d efffffff29 incl _errcnt
135 00022B4F # if ( prt_error ) {
136 00022B4F 5d efffffff23 tstl _prt_error
137 00022B55 21 03 13 009b jeql L236
138 00022B5A # writes(" \n"); /* start a new print line */
139 00022B5A .data 1
140 00000a5e * L237:
141 00000a5e * 200A00 .ascii " \12\0"
142 00000a61 * .text
143 00022B5A dd 8f00000a5e pushl $L237
144 00022B60 fe 08 efffffff11 callf $8,_writes
145 00022B67 # writes("cycle: ");
146 00022B67 .data 1
147 00000a61 * L238:
148 00000a61 * 6379636C653A2000 .ascii "cycle: \0"
149 00000a69 * .text
150 00022B67 dd 8f00000a61 pushl $L238
151 00022B6D fe 08 efffffff04 callf $8,_writes
152 00022B74 # writed( cycle );
153 00022B74 dd effffffefe pushl _cycle
154 00022B7A fe 08 effffffef7 callf $8,_writed
155 00022B81 # writes(" COSF test ");
156 00022B81 .data 1
157 00000a69 * L240:
158 00000a69 * 202020434F534620746573742 .ascii " COSF test \0"
000
159 00000a77 * .text
160 00022B81 dd 8f00000a69 pushl $L240
161 00022B87 fe 08 effffffeea callf $8,_writes
162 00022B8E # writed( test_no );
163 00022B8E dd effffffee4 pushl _test_no
164 00022B94 fe 08 effffffedd callf $8,_writed
165 00022B9B # writes(", subtest 1 (delayed store) - BAD FINAL ACC\n");
166 00022B9B .data 1
167 00000a77 * L241:
168 00000a77 * 2C20737562746573742031202 .ascii ", subtest 1 (delayed store) - BAD FINAL ACC\12\0"
864656C617965642073746F72
6529202D204241442046494E4
14C204143430A00
169 00000aa4 * .text
170 00022B9B dd 8f00000a77 pushl $L241
171 00022BA1 fe 08 effffffed0 callf $8,_writes
172 00022BA8 # print_cosf_data();
173 00022BA8 fe 04 ef0000083b callf $4,_print_cosf_data
174 00022BAF # writes(", data index = ");
175 00022BAF .data 1
176 00000aa4 * L243:
177 00000aa4 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
178 00000ab5 * .text
179 00022BAF dd 8f00000aa4 pushl $L243
180 00022BB5 fe 08 effffffebc callf $8,_writes
181 00022BBC # writed( index );
182 00022BBC dd effffffeb6 pushl _index
183 00022BC2 fe 08 effffffeaf callf $8,_writed
184 00022BC9 # writec('\n');
185 00022BC9 dd 0a pushl $10
186 00022BCB fe 08 effffffea6 callf $8,_writec
187 00022BD2 # writes(" Acc expected = ");
188 00022BD2 .data 1
189 00000ab5 * L245:
190 00000ab5 * 2020202020202020202020202 .ascii " Acc expected = \0"
0202020202020202020416363
206578706563746564203D200
0
191 00000adb * .text
192 00022BD2 dd 8f00000ab5 pushl $L245
193 00022BD8 fe 08 effffffe99 callf $8,_writes
194 00022BDF # write32h( sgl_expected );
195 00022BDF dd effffffe93 pushl _sgl_expected
196 00022BE5 fe 08 effffffe8c callf $8,_write32h
197 00022BEC # writec('\n');
198 00022BEC dd 0a pushl $10
199 00022BEE fe 08 effffffe83 callf $8,_writec
200 00022BF5 # }
201 00022BF5 # if ( halt_flg ) /* halt on error? */
202 00022BF5 L236:
203 00022BF5 5d effffffe7d tstl _halt_flg
204 00022BFB 31 09 jeql L247
205 00022BFD # cosf_er_halt( BAD_ACC_HLT );
206 00022BFD dd 01 pushl $1
207 00022BFF fe 08 ef00000820 callf $8,_cosf_er_halt
208 00022C06 # if ( loop_on_err )
209 00022C06 L247:
210 00022C06 5d effffffe6c tstl _loop_on_err
211 00022C0C 31 0d jeql L249
212 00022C0E # {
213 00022C0E # force_loop = TRUE; /* set the force loop flag */
214 00022C0E 0d 01 effffffe63 movl $1,_force_loop
215 00022C15 # asm("jmp _cosf_1_lp1"); /* and loop */
216 00022C15 71 effffffef6 jmp _cosf_1_lp1
217 00022C1B # }
218 00022C1B # } /* end of compare error */
219 00022C1B L249:
220 00022C1B # } while( index++ < max_cosf_1_index );
221 00022C1B L235:
222 00022C1B L232:
223 00022C1B 0d effffffe57 50 movl _index,r0
224 00022C22 6d effffffe50 incl _index
225 00022C28 1d 50 effffffe49 cmpl r0,_max_cosf_1_index
226 00022C2F 81 03 13 feaa jlss L233
227 00022C34 L231:
228 00022C34 # } /* end of subtest 1 */
229 00022C34 40 ret#2
230 00022C35 .set L227,0x0
231 00022C35 L229:
232 00022C35 13 fe93 jbr L230
233 00022C38 .data
234 00000a58 * .text
235 00022C38 .align 1
236 00022C38 .globl _cosf_2
237 00022C38 _cosf_2:
238 00022C38 0000 .word L250
239 00022C3A #
240 00022C3A #
241 00022C3A #
242 00022C3A # /***************************************************************************
243 00022C3A # *
244 00022C3A # * SUBTEST 2 - COSF FUNCTION
245 00022C3A # *
246 00022C3A # ***************************************************************************/
247 00022C3A # cosf_2()
248 00022C3A # {
249 00022C3A 13 0158 jbr L252
250 00022C3D L253:
251 00022C3D # force_loop = FALSE; /* clear the LOOP flag */
252 00022C3D 4d effffffe35 clrl _force_loop
253 00022C43 # subtest = 2;
254 00022C43 0d 02 effffffe2e movl $2,_subtest
255 00022C4A # index = 0;
256 00022C4A 4d effffffe28 clrl _index
257 00022C50 # do
258 00022C50 L256:
259 00022C50 # {
260 00022C50 # sgl_ld_acc = cosf_1_data[index].ld; /* get the operand */
261 00022C50 0d effffffe22 50 movl _index,r0
262 00022C57 48 03 50 50 shll $3,r0,r0
263 00022C5B 0d e000000000 effffffe12 movl _cosf_1_data(r0),_sgl_ld_acc
264 00022C66 # sgl_expected = cosf_1_data[index].exp; /* get expected results */
265 00022C66 0d effffffe0c 50 movl _index,r0
266 00022C6D 48 03 50 50 shll $3,r0,r0
267 00022C71 0d e000000004 effffffdfc movl _cosf_1_data+4(r0),_sgl_expected
268 00022C7C # /*
269 00022C7C # * If LOOP ON ERROR is set, this is the loop for this subtest.
270 00022C7C # * The force loop flag is set after the first error.
271 00022C7C # */
272 00022C7C # asm("_cosf_2_lp1:");
273 00022C7C _cosf_2_lp1:
274 00022C7C # asm("movl _sgl_ld_acc,r4"); /* set the data to load */
275 00022C7C 0d effffffdf6 54 movl _sgl_ld_acc,r4
276 00022C83 # asm("ldf r4"); /* load the accumulator */
277 00022C83 06 54 ldf r4
278 00022C85 # asm("cosf"); /* get ACC.'s cosine */
279 00022C85 15 cosf
280 00022C86 # asm("stf r5"); /* store the result */
281 00022C86 26 55 stf r5
282 00022C88 # if( force_loop )
283 00022C88 5d effffffdea tstl _force_loop
284 00022C8E 31 02 jeql L257
285 00022C90 # asm("brb _cosf_2_lp1");; /* loop on the error */
286 00022C90 11 ea brb _cosf_2_lp1
287 00022C92 L257:
288 00022C92 # /*
289 00022C92 # * end error loop
290 00022C92 # */
291 00022C92 # asm("movl r5,_sgl_st_acc"); /* save the result */
292 00022C92 0d 55 effffffddf movl r5,_sgl_st_acc
293 00022C99 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
294 00022C99 1d effffffdd9 effffffdd4 cmpl _sgl_st_acc,_sgl_expected
295 00022CA4 21 03 13 00d2 jeql L258
296 00022CA9 # {
297 00022CA9 # errcnt++; /* bump the error count */
298 00022CA9 6d effffffdc9 incl _errcnt
299 00022CAF # if ( prt_error ) {
300 00022CAF 5d effffffdc3 tstl _prt_error
301 00022CB5 21 03 13 009b jeql L259
302 00022CBA # writes(" \n"); /* start a new print line */
303 00022CBA .data 1
304 00000adb * L260:
305 00000adb * 200A00 .ascii " \12\0"
306 00000ade * .text
307 00022CBA dd 8f00000adb pushl $L260
308 00022CC0 fe 08 effffffdb1 callf $8,_writes
309 00022CC7 # writes("cycle: ");
310 00022CC7 .data 1
311 00000ade * L261:
312 00000ade * 6379636C653A2000 .ascii "cycle: \0"
313 00000ae6 * .text
314 00022CC7 dd 8f00000ade pushl $L261
315 00022CCD fe 08 effffffda4 callf $8,_writes
316 00022CD4 # writed( cycle );
317 00022CD4 dd effffffd9e pushl _cycle
318 00022CDA fe 08 effffffd97 callf $8,_writed
319 00022CE1 # writes(" COSF test ");
320 00022CE1 .data 1
321 00000ae6 * L262:
322 00000ae6 * 202020434F534620746573742 .ascii " COSF test \0"
000
323 00000af4 * .text
324 00022CE1 dd 8f00000ae6 pushl $L262
325 00022CE7 fe 08 effffffd8a callf $8,_writes
326 00022CEE # writed( test_no );
327 00022CEE dd effffffd84 pushl _test_no
328 00022CF4 fe 08 effffffd7d callf $8,_writed
329 00022CFB # writes(", subtest 2 (immediate store) - BAD FINAL ACC\n");
330 00022CFB .data 1
331 00000af4 * L263:
332 00000af4 * 2C20737562746573742032202 .ascii ", subtest 2 (immediate store) - BAD FINAL ACC\12\0"
8696D6D656469617465207374
6F726529202D2042414420464
94E414C204143430A00
333 00000b23 * .text
334 00022CFB dd 8f00000af4 pushl $L263
335 00022D01 fe 08 effffffd70 callf $8,_writes
336 00022D08 # print_cosf_data();
337 00022D08 fe 04 ef000006db callf $4,_print_cosf_data
338 00022D0F # writes(", data index = ");
339 00022D0F .data 1
340 00000b23 * L264:
341 00000b23 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
342 00000b34 * .text
343 00022D0F dd 8f00000b23 pushl $L264
344 00022D15 fe 08 effffffd5c callf $8,_writes
345 00022D1C # writed( index );
346 00022D1C dd effffffd56 pushl _index
347 00022D22 fe 08 effffffd4f callf $8,_writed
348 00022D29 # writec('\n');
349 00022D29 dd 0a pushl $10
350 00022D2B fe 08 effffffd46 callf $8,_writec
351 00022D32 # writes(" Acc expected = ");
352 00022D32 .data 1
353 00000b34 * L265:
354 00000b34 * 2020202020202020202020202 .ascii " Acc expected = \0"
0202020202020202020416363
206578706563746564203D200
0
355 00000b5a * .text
356 00022D32 dd 8f00000b34 pushl $L265
357 00022D38 fe 08 effffffd39 callf $8,_writes
358 00022D3F # write32h( sgl_expected );
359 00022D3F dd effffffd33 pushl _sgl_expected
360 00022D45 fe 08 effffffd2c callf $8,_write32h
361 00022D4C # writec('\n');
362 00022D4C dd 0a pushl $10
363 00022D4E fe 08 effffffd23 callf $8,_writec
364 00022D55 # }
365 00022D55 # if ( halt_flg ) /* halt on error? */
366 00022D55 L259:
367 00022D55 5d effffffd1d tstl _halt_flg
368 00022D5B 31 09 jeql L266
369 00022D5D # cosf_er_halt( BAD_ACC_HLT );
370 00022D5D dd 01 pushl $1
371 00022D5F fe 08 ef000006c0 callf $8,_cosf_er_halt
372 00022D66 # if ( loop_on_err )
373 00022D66 L266:
374 00022D66 5d effffffd0c tstl _loop_on_err
375 00022D6C 31 0d jeql L267
376 00022D6E # {
377 00022D6E # force_loop = TRUE; /* set the force loop flag */
378 00022D6E 0d 01 effffffd03 movl $1,_force_loop
379 00022D75 # asm("jmp _cosf_2_lp1"); /* and loop */
380 00022D75 71 efffffff01 jmp _cosf_2_lp1
381 00022D7B # }
382 00022D7B # } /* end of compare error */
383 00022D7B L267:
384 00022D7B # } while( index++ < max_cosf_1_index );
385 00022D7B L258:
386 00022D7B L255:
387 00022D7B 0d effffffcf7 50 movl _index,r0
388 00022D82 6d effffffcf0 incl _index
389 00022D88 1d 50 effffffce9 cmpl r0,_max_cosf_1_index
390 00022D8F 81 03 13 febc jlss L256
391 00022D94 L254:
392 00022D94 # } /* end of subtest 2 */
393 00022D94 40 ret#2
394 00022D95 .set L250,0x0
395 00022D95 L252:
396 00022D95 13 fea5 jbr L253
397 00022D98 .data
398 00000a58 * .text
399 00022D98 .align 1
400 00022D98 .globl _cosf_3
401 00022D98 _cosf_3:
402 00022D98 0000 .word L268
403 00022D9A #
404 00022D9A #
405 00022D9A #
406 00022D9A # /***************************************************************************
407 00022D9A # *
408 00022D9A # * SUBTEST 3 - REGISTER INTEGRITY WITH THE COSF FUNCTION
409 00022D9A # *
410 00022D9A # ***************************************************************************/
411 00022D9A # cosf_3()
412 00022D9A # {
413 00022D9A 13 01e1 jbr L270
414 00022D9D L271:
415 00022D9D # fill_reg_buf( load_regs ); /* set reg values to load */
416 00022D9D dd 8f00000000 pushl $_load_regs
417 00022DA3 fe 08 effffffcce callf $8,_fill_reg_buf
418 00022DAA # force_loop = FALSE; /* clear the LOOP flag */
419 00022DAA 4d effffffcc8 clrl _force_loop
420 00022DB0 # subtest = 3;
421 00022DB0 0d 03 effffffcc1 movl $3,_subtest
422 00022DB7 # index = 0;
423 00022DB7 4d effffffcbb clrl _index
424 00022DBD # do
425 00022DBD L275:
426 00022DBD # {
427 00022DBD # sgl_ld_acc = cosf_1_data[index].ld; /* get the operand */
428 00022DBD 0d effffffcb5 50 movl _index,r0
429 00022DC4 48 03 50 50 shll $3,r0,r0
430 00022DC8 0d e000000000 effffffca5 movl _cosf_1_data(r0),_sgl_ld_acc
431 00022DD3 # sgl_expected = cosf_1_data[index].exp; /* get expected results */
432 00022DD3 0d effffffc9f 50 movl _index,r0
433 00022DDA 48 03 50 50 shll $3,r0,r0
434 00022DDE 0d e000000004 effffffc8f movl _cosf_1_data+4(r0),_sgl_expected
435 00022DE9 # /*
436 00022DE9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
437 00022DE9 # * The force loop flag is set after the first error.
438 00022DE9 # */
439 00022DE9 # asm("_cosf_3_lp1:");
440 00022DE9 _cosf_3_lp1:
441 00022DE9 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
442 00022DE9 ab 891fff effffffc86 loadr $0x1fff,_load_regs
443 00022DF2 # asm("ldf _sgl_ld_acc"); /* load the accumulator */
444 00022DF2 06 effffffc80 ldf _sgl_ld_acc
445 00022DF8 # asm("cosf"); /* get ACC.'s cosf */
446 00022DF8 15 cosf
447 00022DF9 # asm("stf _sgl_st_acc"); /* store the result */
448 00022DF9 26 effffffc79 stf _sgl_st_acc
449 00022DFF # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
450 00022DFF bb 891fff effffffc70 storer $0x1fff,_store_regs
451 00022E08 # if( force_loop )
452 00022E08 5d effffffc6a tstl _force_loop
453 00022E0E 31 02 jeql L276
454 00022E10 # asm("brb _cosf_3_lp1");; /* loop on the error */
455 00022E10 11 d7 brb _cosf_3_lp1
456 00022E12 L276:
457 00022E12 # /*
458 00022E12 # * end error loop
459 00022E12 # */
460 00022E12 # reg_no = 0;
461 00022E12 4d effffffc60 clrl _reg_no
462 00022E18 # regs_ok = TRUE;
463 00022E18 0d 01 effffffc59 movl $1,_regs_ok
464 00022E1F # while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */
465 00022E1F L277:
466 00022E1F 1d effffffc53 0d cmpl _reg_no,$13
467 00022E26 81 35 jgeq L278
468 00022E28 5d effffffc4a tstl _regs_ok
469 00022E2E 31 2d jeql L278
470 00022E30 # if( store_regs[ reg_no ] == load_regs[ reg_no ] )
471 00022E30 0d effffffc42 50 movl _reg_no,r0
472 00022E37 0d effffffc3b 51 movl _reg_no,r1
473 00022E3E 1d 40effffffc33 cmpl _store_regs[r0],_load_regs[r1]
41effffffc2d
474 00022E4B 21 08 jneq L279
475 00022E4D # reg_no++;
476 00022E4D 6d effffffc25 incl _reg_no
477 00022E53 # else
478 00022E53 11 06 jbr L280
479 00022E55 L279:
480 00022E55 # regs_ok = FALSE;
481 00022E55 4d effffffc1d clrl _regs_ok
482 00022E5B L280:
483 00022E5B 11 c2 jbr L277
484 00022E5D L278:
485 00022E5D # if( !regs_ok )
486 00022E5D 5d effffffc15 tstl _regs_ok
487 00022E63 31 03 13 00fc jneq L281
488 00022E68 # {
489 00022E68 # errcnt++; /* bump the error count */
490 00022E68 6d effffffc0a incl _errcnt
491 00022E6E # if ( prt_error ) {
492 00022E6E 5d effffffc04 tstl _prt_error
493 00022E74 21 03 13 00eb jeql L282
494 00022E79 # writes(" \n"); /* start a new print line */
495 00022E79 .data 1
496 00000b5a * L283:
497 00000b5a * 200A00 .ascii " \12\0"
498 00000b5d * .text
499 00022E79 dd 8f00000b5a pushl $L283
500 00022E7F fe 08 effffffbf2 callf $8,_writes
501 00022E86 # writes("cycle: ");
502 00022E86 .data 1
503 00000b5d * L284:
504 00000b5d * 6379636C653A2000 .ascii "cycle: \0"
505 00000b65 * .text
506 00022E86 dd 8f00000b5d pushl $L284
507 00022E8C fe 08 effffffbe5 callf $8,_writes
508 00022E93 # writed( cycle );
509 00022E93 dd effffffbdf pushl _cycle
510 00022E99 fe 08 effffffbd8 callf $8,_writed
511 00022EA0 # writes(" COSF test ");
512 00022EA0 .data 1
513 00000b65 * L285:
514 00000b65 * 202020434F534620746573742 .ascii " COSF test \0"
000
515 00000b73 * .text
516 00022EA0 dd 8f00000b65 pushl $L285
517 00022EA6 fe 08 effffffbcb callf $8,_writes
518 00022EAD # writed( test_no );
519 00022EAD dd effffffbc5 pushl _test_no
520 00022EB3 fe 08 effffffbbe callf $8,_writed
521 00022EBA # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); {
522 00022EBA .data 1
523 00000b73 * L286:
524 00000b73 * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0"
D204120524547495354455220
574153204D4F4449464945440
A00
525 00000b9a * .text
526 00022EBA dd 8f00000b73 pushl $L286
527 00022EC0 fe 08 effffffbb1 callf $8,_writes
528 00022EC7 # print_cosf_data();
529 00022EC7 fe 04 ef0000051c callf $4,_print_cosf_data
530 00022ECE # writec('\n');
531 00022ECE dd 0a pushl $10
532 00022ED0 fe 08 effffffba1 callf $8,_writec
533 00022ED7 # writes("register ");
534 00022ED7 .data 1
535 00000b9a * L287:
536 00000b9a * 72656769737465722000 .ascii "register \0"
537 00000ba4 * .text
538 00022ED7 dd 8f00000b9a pushl $L287
539 00022EDD fe 08 effffffb94 callf $8,_writes
540 00022EE4 # writed( reg_no );
541 00022EE4 dd effffffb8e pushl _reg_no
542 00022EEA fe 08 effffffb87 callf $8,_writed
543 00022EF1 # writes(" = ");
544 00022EF1 .data 1
545 00000ba4 * L288:
546 00000ba4 * 203D2000 .ascii " = \0"
547 00000ba8 * .text
548 00022EF1 dd 8f00000ba4 pushl $L288
549 00022EF7 fe 08 effffffb7a callf $8,_writes
550 00022EFE # write32h( load_regs[reg_no] );
551 00022EFE 0d effffffb74 50 movl _reg_no,r0
552 00022F05 dd 40effffffb6c pushl _load_regs[r0]
553 00022F0C fe 08 effffffb65 callf $8,_write32h
554 00022F13 # writes(", should be = ");
555 00022F13 .data 1
556 00000ba8 * L289:
557 00000ba8 * 2C202073686F756C642062652 .ascii ", should be = \0"
03D2000
558 00000bb8 * .text
559 00022F13 dd 8f00000ba8 pushl $L289
560 00022F19 fe 08 effffffb58 callf $8,_writes
561 00022F20 # write32h( store_regs[reg_no] );
562 00022F20 0d effffffb52 50 movl _reg_no,r0
563 00022F27 dd 40effffffb4a pushl _store_regs[r0]
564 00022F2E fe 08 effffffb43 callf $8,_write32h
565 00022F35 # writec('\n');
566 00022F35 dd 0a pushl $10
567 00022F37 fe 08 effffffb3a callf $8,_writec
568 00022F3E # }
569 00022F3E # if ( halt_flg ) /* halt on error? */
570 00022F3E 5d effffffb34 tstl _halt_flg
571 00022F44 31 09 jeql L290
572 00022F46 # cosf_er_halt( BAD_REG_HLT );
573 00022F46 dd 02 pushl $2
574 00022F48 fe 08 ef000004d7 callf $8,_cosf_er_halt
575 00022F4F # if ( loop_on_err )
576 00022F4F L290:
577 00022F4F 5d effffffb23 tstl _loop_on_err
578 00022F55 31 0d jeql L291
579 00022F57 # {
580 00022F57 # force_loop = TRUE; /* get the force loop flag */
581 00022F57 0d 01 effffffb1a movl $1,_force_loop
582 00022F5E # asm("jmp _cosf_3_lp1"); /* and loop */
583 00022F5E 71 effffffe85 jmp _cosf_3_lp1
584 00022F64 # }
585 00022F64 # } /* end of compare error */
586 00022F64 L291:
587 00022F64 # } /* end of while loop */
588 00022F64 L282:
589 00022F64 # } while( index++ < max_cosf_1_index );
590 00022F64 L281:
591 00022F64 L274:
592 00022F64 0d effffffb0e 50 movl _index,r0
593 00022F6B 6d effffffb07 incl _index
594 00022F71 1d 50 effffffb00 cmpl r0,_max_cosf_1_index
595 00022F78 81 03 13 fe40 jlss L275
596 00022F7D L273:
597 00022F7D # } /* end of subtest 3 */
598 00022F7D 40 ret#2
599 00022F7E .set L268,0x0
600 00022F7E L270:
601 00022F7E 13 fe1c jbr L271
602 00022F81 .data
603 00000a58 * .text
604 00022F81 00 .align 1
605 00022F82 .globl _cosf_4
606 00022F82 _cosf_4:
607 00022F82 0000 .word L293
608 00022F84 #
609 00022F84 #
610 00022F84 #
611 00022F84 # /************************************************************************
612 00022F84 # *
613 00022F84 # * SUBTEST 4 - Check for PSL corruption
614 00022F84 # *
615 00022F84 # ************************************************************************/
616 00022F84 # cosf_4()
617 00022F84 # {
618 00022F84 13 01a8 jbr L295
619 00022F87 L296:
620 00022F87 # force_loop = FALSE; /* clear force_loop flg */
621 00022F87 4d effffffaeb clrl _force_loop
622 00022F8D # subtest = 4;
623 00022F8D 0d 04 effffffae4 movl $4,_subtest
624 00022F94 # fill_reg_buf( load_regs ); /* get patterns for regs */
625 00022F94 dd 8f00000000 pushl $_load_regs
626 00022F9A fe 08 effffffad7 callf $8,_fill_reg_buf
627 00022FA1 # for( index = 0; index < 3; index++ ) {
628 00022FA1 4d effffffad1 clrl _index
629 00022FA7 L299:
630 00022FA7 1d effffffacb 03 cmpl _index,$3
631 00022FAE 91 03 13 017b jgeq L298
632 00022FB3 # sgl_ld_acc = cosf_1_data[index].ld; /* get operand 1 */
633 00022FB3 0d effffffabf 50 movl _index,r0
634 00022FBA 48 03 50 50 shll $3,r0,r0
635 00022FBE 0d e000000000 effffffaaf movl _cosf_1_data(r0),_sgl_ld_acc
636 00022FC9 # sgl_expected = cosf_1_data[index].exp; /* get expected */
637 00022FC9 0d effffffaa9 50 movl _index,r0
638 00022FD0 48 03 50 50 shll $3,r0,r0
639 00022FD4 0d e000000004 effffffa99 movl _cosf_1_data+4(r0),_sgl_expected
640 00022FDF # sgl_dummy1 = status_array[index]; /* status = +, -, 0 */
641 00022FDF 0d effffffa93 50 movl _index,r0
642 00022FE6 0d 40effffffa8b movl _status_array[r0],_sgl_dummy1
effffffa86
643 00022FF2 # /*
644 00022FF2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
645 00022FF2 # * The force loop flag is set after the first error.
646 00022FF2 # */
647 00022FF2 # asm("_cosf_4_lp1:");
648 00022FF2 _cosf_4_lp1:
649 00022FF2 # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
650 00022FF2 06 effffffa80 ldf _sgl_ld_acc
651 00022FF8 # asm("nop");
652 00022FF8 10 nop
653 00022FF9 # asm("tstl _sgl_dummy1"); /* set the PSL status */
654 00022FF9 5d effffffa79 tstl _sgl_dummy1
655 00022FFF # asm("movpsl _init_psl"); /* save the initial PSL */
656 00022FFF cd effffffa73 movpsl _init_psl
657 00023005 # asm("cosf"); /* do the cosf */
658 00023005 15 cosf
659 00023006 # asm("nop");
660 00023006 10 nop
661 00023007 # asm("movpsl _psl_val"); /* save the final PSL */
662 00023007 cd effffffa6b movpsl _psl_val
663 0002300D # asm("stf _sgl_st_acc"); /* save the accumulator */
664 0002300D 26 effffffa65 stf _sgl_st_acc
665 00023013 # if( force_loop )
666 00023013 5d effffffa5f tstl _force_loop
667 00023019 31 02 jeql L300
668 0002301B # asm("brb _cosf_4_lp1");; /* loop on the error */
669 0002301B 11 d5 brb _cosf_4_lp1
670 0002301D L300:
671 0002301D # /*
672 0002301D # * Now compare the final PSL to the initial PSL -they should be the same
673 0002301D # */
674 0002301D # exp_psl = init_psl;
675 0002301D 0d effffffa55 effffffa50 movl _init_psl,_exp_psl
676 00023028 # if( psl_val != exp_psl ) {
677 00023028 1d effffffa4a effffffa45 cmpl _psl_val,_exp_psl
678 00023033 21 03 13 00ed jeql L301
679 00023038 # errcnt++; /* bump the error count */
680 00023038 6d effffffa3a incl _errcnt
681 0002303E # if( prt_error ) {
682 0002303E 5d effffffa34 tstl _prt_error
683 00023044 21 03 13 00b9 jeql L302
684 00023049 # writes(" \n"); /* start a new print line */
685 00023049 .data 1
686 00000bb8 * L303:
687 00000bb8 * 200A00 .ascii " \12\0"
688 00000bbb * .text
689 00023049 dd 8f00000bb8 pushl $L303
690 0002304F fe 08 effffffa22 callf $8,_writes
691 00023056 # writes("cycle: ");
692 00023056 .data 1
693 00000bbb * L304:
694 00000bbb * 6379636C653A2000 .ascii "cycle: \0"
695 00000bc3 * .text
696 00023056 dd 8f00000bbb pushl $L304
697 0002305C fe 08 effffffa15 callf $8,_writes
698 00023063 # writed( cycle );
699 00023063 dd effffffa0f pushl _cycle
700 00023069 fe 08 effffffa08 callf $8,_writed
701 00023070 # writes(" COSF test ");
702 00023070 .data 1
703 00000bc3 * L305:
704 00000bc3 * 202020434F534620746573742 .ascii " COSF test \0"
000
705 00000bd1 * .text
706 00023070 dd 8f00000bc3 pushl $L305
707 00023076 fe 08 effffff9fb callf $8,_writes
708 0002307D # writed( test_no );
709 0002307D dd effffff9f5 pushl _test_no
710 00023083 fe 08 effffff9ee callf $8,_writed
711 0002308A # writes(", subtest 4 - INCORRECT FINAL PSL\n");
712 0002308A .data 1
713 00000bd1 * L306:
714 00000bd1 * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0"
D20494E434F52524543542046
494E414C2050534C0A00
715 00000bf4 * .text
716 0002308A dd 8f00000bd1 pushl $L306
717 00023090 fe 08 effffff9e1 callf $8,_writes
718 00023097 # print_cosf_data(); /* print the operands */
719 00023097 fe 04 ef0000034c callf $4,_print_cosf_data
720 0002309E # writec('\n');
721 0002309E dd 0a pushl $10
722 000230A0 fe 08 effffff9d1 callf $8,_writec
723 000230A7 # writes("initial PSL = ");
724 000230A7 .data 1
725 00000bf4 * L307:
726 00000bf4 * 696E697469616C2050534C203 .ascii "initial PSL = \0"
D2000
727 00000c03 * .text
728 000230A7 dd 8f00000bf4 pushl $L307
729 000230AD fe 08 effffff9c4 callf $8,_writes
730 000230B4 # write32h( init_psl );
731 000230B4 dd effffff9be pushl _init_psl
732 000230BA fe 08 effffff9b7 callf $8,_write32h
733 000230C1 # writes(", final PSL = ");
734 000230C1 .data 1
735 00000c03 * L308:
736 00000c03 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
03D2000
737 00000c13 * .text
738 000230C1 dd 8f00000c03 pushl $L308
739 000230C7 fe 08 effffff9aa callf $8,_writes
740 000230CE # write32h( psl_val );
741 000230CE dd effffff9a4 pushl _psl_val
742 000230D4 fe 08 effffff99d callf $8,_write32h
743 000230DB # writes(", expected PSL = ");
744 000230DB .data 1
745 00000c13 * L309:
746 00000c13 * 2C20206578706563746564205 .ascii ", expected PSL = \0"
0534C203D2000
747 00000c26 * .text
748 000230DB dd 8f00000c13 pushl $L309
749 000230E1 fe 08 effffff990 callf $8,_writes
750 000230E8 # write32h( exp_psl );
751 000230E8 dd effffff98a pushl _exp_psl
752 000230EE fe 08 effffff983 callf $8,_write32h
753 000230F5 # writes("\n");
754 000230F5 .data 1
755 00000c26 * L310:
756 00000c26 * 0A00 .ascii "\12\0"
757 00000c28 * .text
758 000230F5 dd 8f00000c26 pushl $L310
759 000230FB fe 08 effffff976 callf $8,_writes
760 00023102 # }
761 00023102 # if( halt_flg )
762 00023102 L302:
763 00023102 5d effffff970 tstl _halt_flg
764 00023108 31 09 jeql L311
765 0002310A # cosf_er_halt( BAD_PSL_HLT ); /* halt on the error */
766 0002310A dd 03 pushl $3
767 0002310C fe 08 ef00000313 callf $8,_cosf_er_halt
768 00023113 # if( loop_on_err ) {
769 00023113 L311:
770 00023113 5d effffff95f tstl _loop_on_err
771 00023119 31 0a jeql L312
772 0002311B # force_loop = TRUE; /* set the force loop flag */
773 0002311B 0d 01 effffff956 movl $1,_force_loop
774 00023122 # asm("brw _cosf_4_lp1");; /* and loop on the error */
775 00023122 13 fecd brw _cosf_4_lp1
776 00023125 # } /* end of loop on error */
777 00023125 # } /* end of PSL corruption error */
778 00023125 L312:
779 00023125 # } /* end of WHILE loop */
780 00023125 L301:
781 00023125 L297:
782 00023125 6d effffff94d incl _index
783 0002312B 13 fe79 jbr L299
784 0002312E L298:
785 0002312E # } /* end of subtest 4 */
786 0002312E 40 ret#2
787 0002312F .set L293,0x0
788 0002312F L295:
789 0002312F 13 fe55 jbr L296
790 00023132 .data
791 00000a58 * .text
792 00023132 .align 1
793 00023132 .globl _cosf_5
794 00023132 _cosf_5:
795 00023132 0000 .word L313
796 00023134 #
797 00023134 #
798 00023134 #
799 00023134 # /************************************************************************
800 00023134 # *
801 00023134 # * SUBTEST 5 - pipelined entry test
802 00023134 # *
803 00023134 # ************************************************************************/
804 00023134 # cosf_5()
805 00023134 # {
806 00023134 13 0154 jbr L315
807 00023137 L316:
808 00023137 # force_loop = FALSE;
809 00023137 4d effffff93b clrl _force_loop
810 0002313D # subtest = 8;
811 0002313D 0d 08 effffff934 movl $8,_subtest
812 00023144 # for( index = 0; index < max_cosf_1_index; index++ ) {
813 00023144 4d effffff92e clrl _index
814 0002314A L319:
815 0002314A 1d effffff928 effffff923 cmpl _index,_max_cosf_1_index
816 00023155 91 03 13 0130 jgeq L318
817 0002315A # sgl_ld_acc = cosf_1_data[index].ld; /* get operand 1 */
818 0002315A 0d effffff918 50 movl _index,r0
819 00023161 48 03 50 50 shll $3,r0,r0
820 00023165 0d e000000000 effffff908 movl _cosf_1_data(r0),_sgl_ld_acc
821 00023170 # sgl_expected = cosf_1_data[index].exp; /* get expected result */
822 00023170 0d effffff902 50 movl _index,r0
823 00023177 48 03 50 50 shll $3,r0,r0
824 0002317B 0d e000000004 effffff8f2 movl _cosf_1_data+4(r0),_sgl_expected
825 00023186 # /*
826 00023186 # * If LOOP ON ERROR is set, this is the loop for this subtest.
827 00023186 # * The force loop flag is set after the first error.
828 00023186 # */
829 00023186 # asm("_cosf_5_lp1:");
830 00023186 _cosf_5_lp1:
831 00023186 # asm("movl $0,r0"); /* clear r0 */
832 00023186 0d 00 50 movl $0,r0
833 00023189 # asm("ldf r0"); /* load the Acc. with 0.0 */
834 00023189 06 50 ldf r0
835 0002318B # asm("addf _sgl_ld_acc"); /* add the 1st operand */
836 0002318B c6 effffff8e7 addf _sgl_ld_acc
837 00023191 # asm("cosf"); /* get the cosf */
838 00023191 15 cosf
839 00023192 # asm("stf _sgl_st_acc"); /* store the result */
840 00023192 26 effffff8e0 stf _sgl_st_acc
841 00023198 # if( force_loop )
842 00023198 5d effffff8da tstl _force_loop
843 0002319E 31 02 jeql L320
844 000231A0 # asm("brb _cosf_5_lp1");; /* loop on the error */
845 000231A0 11 e4 brb _cosf_5_lp1
846 000231A2 L320:
847 000231A2 # /*
848 000231A2 # * end error loop - test the results
849 000231A2 # */
850 000231A2 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
851 000231A2 1d effffff8d0 effffff8cb cmpl _sgl_st_acc,_sgl_expected
852 000231AD 21 03 13 00cf jeql L321
853 000231B2 # errcnt++; /* bump the error count */
854 000231B2 6d effffff8c0 incl _errcnt
855 000231B8 # if( prt_error ) {
856 000231B8 5d effffff8ba tstl _prt_error
857 000231BE 21 03 13 009b jeql L322
858 000231C3 # writes(" \n"); /* start a new print line */
859 000231C3 .data 1
860 00000c28 * L323:
861 00000c28 * 200A00 .ascii " \12\0"
862 00000c2b * .text
863 000231C3 dd 8f00000c28 pushl $L323
864 000231C9 fe 08 effffff8a8 callf $8,_writes
865 000231D0 # writes("cycle: ");
866 000231D0 .data 1
867 00000c2b * L324:
868 00000c2b * 6379636C653A2000 .ascii "cycle: \0"
869 00000c33 * .text
870 000231D0 dd 8f00000c2b pushl $L324
871 000231D6 fe 08 effffff89b callf $8,_writes
872 000231DD # writed( cycle );
873 000231DD dd effffff895 pushl _cycle
874 000231E3 fe 08 effffff88e callf $8,_writed
875 000231EA # writes(" COSF test ");
876 000231EA .data 1
877 00000c33 * L325:
878 00000c33 * 202020434F534620746573742 .ascii " COSF test \0"
000
879 00000c41 * .text
880 000231EA dd 8f00000c33 pushl $L325
881 000231F0 fe 08 effffff881 callf $8,_writes
882 000231F7 # writed( test_no );
883 000231F7 dd effffff87b pushl _test_no
884 000231FD fe 08 effffff874 callf $8,_writed
885 00023204 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n");
886 00023204 .data 1
887 00000c41 * L326:
888 00000c41 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0"
8506970656420456E74727929
202D204241442046494E414C2
04143430A00
889 00000c6c * .text
890 00023204 dd 8f00000c41 pushl $L326
891 0002320A fe 08 effffff867 callf $8,_writes
892 00023211 # print_cosf_data();
893 00023211 fe 04 ef000001d2 callf $4,_print_cosf_data
894 00023218 # writes(", data index = ");
895 00023218 .data 1
896 00000c6c * L327:
897 00000c6c * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
898 00000c7d * .text
899 00023218 dd 8f00000c6c pushl $L327
900 0002321E fe 08 effffff853 callf $8,_writes
901 00023225 # writed( index );
902 00023225 dd effffff84d pushl _index
903 0002322B fe 08 effffff846 callf $8,_writed
904 00023232 # writec('\n');
905 00023232 dd 0a pushl $10
906 00023234 fe 08 effffff83d callf $8,_writec
907 0002323B # writes(" Acc expected = ");
908 0002323B .data 1
909 00000c7d * L328:
910 00000c7d * 2020202020202020202020202 .ascii " Acc expected = \0"
0202020202020202020416363
206578706563746564203D200
0
911 00000ca3 * .text
912 0002323B dd 8f00000c7d pushl $L328
913 00023241 fe 08 effffff830 callf $8,_writes
914 00023248 # write32h( sgl_expected );
915 00023248 dd effffff82a pushl _sgl_expected
916 0002324E fe 08 effffff823 callf $8,_write32h
917 00023255 # writec('\n');
918 00023255 dd 0a pushl $10
919 00023257 fe 08 effffff81a callf $8,_writec
920 0002325E # }
921 0002325E # if( halt_flg )
922 0002325E L322:
923 0002325E 5d effffff814 tstl _halt_flg
924 00023264 31 09 jeql L329
925 00023266 # cosf_er_halt( BAD_ACC_HLT ); /* halt on the error */
926 00023266 dd 01 pushl $1
927 00023268 fe 08 ef000001b7 callf $8,_cosf_er_halt
928 0002326F # if( loop_on_err ) {
929 0002326F L329:
930 0002326F 5d effffff803 tstl _loop_on_err
931 00023275 31 0a jeql L330
932 00023277 # force_loop = TRUE; /* set the force loop flag */
933 00023277 0d 01 effffff7fa movl $1,_force_loop
934 0002327E # asm("brw _cosf_5_lp1");; /* and loop on the error */
935 0002327E 13 ff05 brw _cosf_5_lp1
936 00023281 # } /* end of loop on error */
937 00023281 # } /* end of compare error */
938 00023281 L330:
939 00023281 # } /* end of WHILE loop */
940 00023281 L321:
941 00023281 L317:
942 00023281 6d effffff7f1 incl _index
943 00023287 13 fec0 jbr L319
944 0002328A L318:
945 0002328A # } /* end of subtest 5 */
946 0002328A 40 ret#2
947 0002328B .set L313,0x0
948 0002328B L315:
949 0002328B 13 fea9 jbr L316
950 0002328E .data
951 00000a58 * .text
952 0002328E .align 1
953 0002328E .globl _cosf_6
954 0002328E _cosf_6:
955 0002328E 0000 .word L331
956 00023290 #
957 00023290 #
958 00023290 #
959 00023290 # /************************************************************************
960 00023290 # *
961 00023290 # * SUBTEST 6 - pipelined exit test
962 00023290 # *
963 00023290 # ************************************************************************/
964 00023290 # cosf_6()
965 00023290 # {
966 00023290 13 0154 jbr L333
967 00023293 L334:
968 00023293 # force_loop = FALSE;
969 00023293 4d effffff7df clrl _force_loop
970 00023299 # subtest = 8;
971 00023299 0d 08 effffff7d8 movl $8,_subtest
972 000232A0 # for( index = 0; index < max_cosf_1_index; index++ ) {
973 000232A0 4d effffff7d2 clrl _index
974 000232A6 L337:
975 000232A6 1d effffff7cc effffff7c7 cmpl _index,_max_cosf_1_index
976 000232B1 91 03 13 0130 jgeq L336
977 000232B6 # sgl_ld_acc = cosf_1_data[index].ld; /* get operand 1 */
978 000232B6 0d effffff7bc 50 movl _index,r0
979 000232BD 48 03 50 50 shll $3,r0,r0
980 000232C1 0d e000000000 effffff7ac movl _cosf_1_data(r0),_sgl_ld_acc
981 000232CC # sgl_expected = cosf_1_data[index].exp; /* get expected result */
982 000232CC 0d effffff7a6 50 movl _index,r0
983 000232D3 48 03 50 50 shll $3,r0,r0
984 000232D7 0d e000000004 effffff796 movl _cosf_1_data+4(r0),_sgl_expected
985 000232E2 # /*
986 000232E2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
987 000232E2 # * The force loop flag is set after the first error.
988 000232E2 # */
989 000232E2 # asm("_cosf_6_lp1:");
990 000232E2 _cosf_6_lp1:
991 000232E2 # asm("movl $0,r0"); /* clear r0 */
992 000232E2 0d 00 50 movl $0,r0
993 000232E5 # asm("ldf _sgl_ld_acc"); /* load the Acc. */
994 000232E5 06 effffff78d ldf _sgl_ld_acc
995 000232EB # asm("cosf"); /* get the cosf */
996 000232EB 15 cosf
997 000232EC # asm("addf r0"); /* add a zero to the acc */
998 000232EC c6 50 addf r0
999 000232EE # asm("stf _sgl_st_acc"); /* store the result */
1000 000232EE 26 effffff784 stf _sgl_st_acc
1001 000232F4 # if( force_loop )
1002 000232F4 5d effffff77e tstl _force_loop
1003 000232FA 31 02 jeql L338
1004 000232FC # asm("brb _cosf_6_lp1");; /* loop on the error */
1005 000232FC 11 e4 brb _cosf_6_lp1
1006 000232FE L338:
1007 000232FE # /*
1008 000232FE # * end error loop - test the results
1009 000232FE # */
1010 000232FE # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1011 000232FE 1d effffff774 effffff76f cmpl _sgl_st_acc,_sgl_expected
1012 00023309 21 03 13 00cf jeql L339
1013 0002330E # errcnt++; /* bump the error count */
1014 0002330E 6d effffff764 incl _errcnt
1015 00023314 # if( prt_error ) {
1016 00023314 5d effffff75e tstl _prt_error
1017 0002331A 21 03 13 009b jeql L340
1018 0002331F # writes(" \n"); /* start a new print line */
1019 0002331F .data 1
1020 00000ca3 * L341:
1021 00000ca3 * 200A00 .ascii " \12\0"
1022 00000ca6 * .text
1023 0002331F dd 8f00000ca3 pushl $L341
1024 00023325 fe 08 effffff74c callf $8,_writes
1025 0002332C # writes("cycle: ");
1026 0002332C .data 1
1027 00000ca6 * L342:
1028 00000ca6 * 6379636C653A2000 .ascii "cycle: \0"
1029 00000cae * .text
1030 0002332C dd 8f00000ca6 pushl $L342
1031 00023332 fe 08 effffff73f callf $8,_writes
1032 00023339 # writed( cycle );
1033 00023339 dd effffff739 pushl _cycle
1034 0002333F fe 08 effffff732 callf $8,_writed
1035 00023346 # writes(" COSF test ");
1036 00023346 .data 1
1037 00000cae * L343:
1038 00000cae * 202020434F534620746573742 .ascii " COSF test \0"
000
1039 00000cbc * .text
1040 00023346 dd 8f00000cae pushl $L343
1041 0002334C fe 08 effffff725 callf $8,_writes
1042 00023353 # writed( test_no );
1043 00023353 dd effffff71f pushl _test_no
1044 00023359 fe 08 effffff718 callf $8,_writed
1045 00023360 # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n");
1046 00023360 .data 1
1047 00000cbc * L344:
1048 00000cbc * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0"
8506970656420457869742920
2D204241442046494E414C204
143430A00
1049 00000ce6 * .text
1050 00023360 dd 8f00000cbc pushl $L344
1051 00023366 fe 08 effffff70b callf $8,_writes
1052 0002336D # print_cosf_data();
1053 0002336D fe 04 ef00000076 callf $4,_print_cosf_data
1054 00023374 # writes(", data index = ");
1055 00023374 .data 1
1056 00000ce6 * L345:
1057 00000ce6 * 2C20206461746120696E64657 .ascii ", data index = \0"
8203D2000
1058 00000cf7 * .text
1059 00023374 dd 8f00000ce6 pushl $L345
1060 0002337A fe 08 effffff6f7 callf $8,_writes
1061 00023381 # writed( index );
1062 00023381 dd effffff6f1 pushl _index
1063 00023387 fe 08 effffff6ea callf $8,_writed
1064 0002338E # writec('\n');
1065 0002338E dd 0a pushl $10
1066 00023390 fe 08 effffff6e1 callf $8,_writec
1067 00023397 # writes(" Acc expected = ");
1068 00023397 .data 1
1069 00000cf7 * L346:
1070 00000cf7 * 2020202020202020202020202 .ascii " Acc expected = \0"
0202020202020202020416363
206578706563746564203D200
0
1071 00000d1d * .text
1072 00023397 dd 8f00000cf7 pushl $L346
1073 0002339D fe 08 effffff6d4 callf $8,_writes
1074 000233A4 # write32h( sgl_expected );
1075 000233A4 dd effffff6ce pushl _sgl_expected
1076 000233AA fe 08 effffff6c7 callf $8,_write32h
1077 000233B1 # writec('\n');
1078 000233B1 dd 0a pushl $10
1079 000233B3 fe 08 effffff6be callf $8,_writec
1080 000233BA # }
1081 000233BA # if( halt_flg )
1082 000233BA L340:
1083 000233BA 5d effffff6b8 tstl _halt_flg
1084 000233C0 31 09 jeql L347
1085 000233C2 # cosf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1086 000233C2 dd 01 pushl $1
1087 000233C4 fe 08 ef0000005b callf $8,_cosf_er_halt
1088 000233CB # if( loop_on_err ) {
1089 000233CB L347:
1090 000233CB 5d effffff6a7 tstl _loop_on_err
1091 000233D1 31 0a jeql L348
1092 000233D3 # force_loop = TRUE; /* set the force loop flag */
1093 000233D3 0d 01 effffff69e movl $1,_force_loop
1094 000233DA # asm("brw _cosf_6_lp1");; /* and loop on the error */
1095 000233DA 13 ff05 brw _cosf_6_lp1
1096 000233DD # } /* end of loop on error */
1097 000233DD # } /* end of compare error */
1098 000233DD L348:
1099 000233DD # } /* end of WHILE loop */
1100 000233DD L339:
1101 000233DD L335:
1102 000233DD 6d effffff695 incl _index
1103 000233E3 13 fec0 jbr L337
1104 000233E6 L336:
1105 000233E6 # } /* end of subtest 6 */
1106 000233E6 40 ret#2
1107 000233E7 .set L331,0x0
1108 000233E7 L333:
1109 000233E7 13 fea9 jbr L334
1110 000233EA .data
1111 00000a58 * .text
1112 000233EA .align 1
1113 000233EA .globl _print_cosf_data
1114 000233EA _print_cosf_data:
1115 000233EA 0000 .word L349
1116 000233EC #
1117 000233EC #
1118 000233EC # /**************************************************************************
1119 000233EC # *
1120 000233EC # * PRINT THE DATA AND STORE RESULTS
1121 000233EC # *
1122 000233EC # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1123 000233EC # * Acc expected = xxxxxxxx
1124 000233EC # **************************************************************************/
1125 000233EC # print_cosf_data()
1126 000233EC # {
1127 000233EC 11 35 jbr L351
1128 000233EE L352:
1129 000233EE # writes("initial Acc = ");
1130 000233EE .data 1
1131 00000d1d * L353:
1132 00000d1d * 696E697469616C20416363203 .ascii "initial Acc = \0"
D2000
1133 00000d2c * .text
1134 000233EE dd 8f00000d1d pushl $L353
1135 000233F4 fe 08 effffff67d callf $8,_writes
1136 000233FB # write32h( sgl_ld_acc );
1137 000233FB dd effffff677 pushl _sgl_ld_acc
1138 00023401 fe 08 effffff670 callf $8,_write32h
1139 00023408 # writes(", final Acc = ");
1140 00023408 .data 1
1141 00000d2c * L354:
1142 00000d2c * 2C202066696E616C204163632 .ascii ", final Acc = \0"
03D2000
1143 00000d3c * .text
1144 00023408 dd 8f00000d2c pushl $L354
1145 0002340E fe 08 effffff663 callf $8,_writes
1146 00023415 # write32h( sgl_st_acc );
1147 00023415 dd effffff65d pushl _sgl_st_acc
1148 0002341B fe 08 effffff656 callf $8,_write32h
1149 00023422 # }
1150 00023422 40 ret#2
1151 00023423 .set L349,0x0
1152 00023423 L351:
1153 00023423 11 c9 jbr L352
1154 00023425 .data
1155 00000a58 * .text
1156 00023425 00 .align 1
1157 00023426 .globl _cosf_er_halt
1158 00023426 _cosf_er_halt:
1159 00023426 0000 .word L355
1160 00023428 #
1161 00023428 #
1162 00023428 #
1163 00023428 # /**************************************************************************
1164 00023428 # *
1165 00023428 # * HALT ON ERROR ROUTINE
1166 00023428 # *
1167 00023428 # **************************************************************************/
1168 00023428 # cosf_er_halt( halt_code )
1169 00023428 # int halt_code;
1170 00023428 # {
1171 00023428 13 00a0 jbr L357
1172 0002342B L358:
1173 0002342B # sgl_dummy1 = halt_code; /* get the error type */
1174 0002342B 0d ad04 effffff645 movl 4(fp),_sgl_dummy1
1175 00023433 # asm("movl _test_no,r0"); /* r0 = test number */
1176 00023433 0d effffff63f 50 movl _test_no,r0
1177 0002343A # asm("movl _subtest,r1"); /* r1 = subtest number */
1178 0002343A 0d effffff638 51 movl _subtest,r1
1179 00023441 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1180 00023441 0d effffff631 52 movl _sgl_dummy1,r2
1181 00023448 # asm("movl _cycle,r3"); /* r3 = cycle count */
1182 00023448 0d effffff62a 53 movl _cycle,r3
1183 0002344F # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1184 0002344F 0d effffff623 54 movl _sgl_ld_acc,r4
1185 00023456 # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */
1186 00023456 0d effffff61c 55 movl _sgl_st_acc,r5
1187 0002345D # asm("movl _sgl_expected,r6"); /* r6 = data expected */
1188 0002345D 0d effffff615 56 movl _sgl_expected,r6
1189 00023464 # asm("movl _index,r7"); /* r7 = data index */
1190 00023464 0d effffff60e 57 movl _index,r7
1191 0002346B # if( halt_code == BAD_REG_HLT ) {
1192 0002346B 1d ad04 02 cmpl 4(fp),$2
1193 0002346F 21 3d jneq L359
1194 00023471 # sgl_dummy1 = load_regs[index2];
1195 00023471 0d effffff601 50 movl _index2,r0
1196 00023478 0d 40effffff5f9 movl _load_regs[r0],_sgl_dummy1
effffff5f4
1197 00023484 # sgl_dummy2 = store_regs[index2];
1198 00023484 0d effffff5ee 50 movl _index2,r0
1199 0002348B 0d 40effffff5e6 movl _store_regs[r0],_sgl_dummy2
effffff5e1
1200 00023497 # asm("movl _index2,r6"); /* r6 = bad register # */
1201 00023497 0d effffff5db 56 movl _index2,r6
1202 0002349E # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */
1203 0002349E 0d effffff5d4 57 movl _sgl_dummy2,r7
1204 000234A5 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */
1205 000234A5 0d effffff5cd 58 movl _sgl_dummy1,r8
1206 000234AC # } else
1207 000234AC 11 1b jbr L360
1208 000234AE L359:
1209 000234AE # if( halt_code == BAD_PSL_HLT ) {
1210 000234AE 1d ad04 03 cmpl 4(fp),$3
1211 000234B2 21 15 jneq L361
1212 000234B4 # asm("movl _init_psl,r6"); /* r6 = initial PSL */
1213 000234B4 0d effffff5be 56 movl _init_psl,r6
1214 000234BB # asm("movl _psl_val,r7"); /* r7 = final PSL */
1215 000234BB 0d effffff5b7 57 movl _psl_val,r7
1216 000234C2 # asm("movl _exp_psl,r8"); /* r8 = expected PSL */
1217 000234C2 0d effffff5b0 58 movl _exp_psl,r8
1218 000234C9 # };
1219 000234C9 L361:
1220 000234C9 L360:
1221 000234C9 # asm("halt"); /* HALT ... */
1222 000234C9 00 halt
1223 000234CA # }
1224 000234CA 40 ret#2
1225 000234CB .set L355,0x0
1226 000234CB L357:
1227 000234CB 13 ff5d jbr L358
1228 000234CE .data
1228 00045F46 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.