![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sqrtf.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 sqrtf.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1: 1 00000000 LL0:
2: 2 00000000 .data
3: 3 00000a60 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _sqrtf
6: 6 00000000 _sqrtf:
7: 7 000200FC 0000 .word L215
8: 8 000200FE # #include "fpp_defs.h"
9: 9 000200FE #
10: 10 000200FE #
11: 11 000200FE #
12: 12 000200FE # /***************************************************************************
13: 13 000200FE # *
14: 14 000200FE # * SQRTF - SINGLE PRECISION FLOATING POINT SQUARE-ROOT FUNCTION TEST
15: 15 000200FE # *
16: 16 000200FE # * SQRTF TEST MONITOR
17: 17 000200FE # *
18: 18 000200FE # *****************************************************************************/
19: 19 000200FE # sqrtf()
20: 20 000200FE # {
21: 21 000200FE 11 4f jbr L217
22: 22 00020100 L218:
23: 23 00020100 # asm(".globl _sqrtf_t");
24: 24 00020100 .globl _sqrtf_t
25: 25 00020100 # asm("_sqrtf_t:"); /* entry address */
26: 26 00020100 _sqrtf_t:
27: 27 00020100 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
28: 28 00020100 1d effffffff6 01 cmpl _cycle,$1
29: 29 00020107 21 15 jneq L219
30: 30 00020109 5d efffffffed tstl _prt_hdrs
31: 31 0002010F 31 0d jeql L219
32: 32 00020111 # {
33: 33 00020111 # writes(" SQRTF");
34: 34 00020111 .data 1
35: 35 00000a60 * L221:
36: 36 00000a60 * 20535152544600 .ascii " SQRTF\0"
37: 37 00000a67 * .text
38: 38 00020111 dd 8f00000a60 pushl $L221
39: 39 00020117 fe 08 efffffffde callf $8,_writes
40: 40 0002011E # }
41: 41 0002011E # sqrtf_1(); /* test square root w/ delay */
42: 42 0002011E L219:
43: 43 0002011E fe 04 ef0000002d callf $4,_sqrtf_1
44: 44 00020125 # sqrtf_2(); /* test square root */
45: 45 00020125 fe 04 ef00000198 callf $4,_sqrtf_2
46: 46 0002012C # sqrtf_3(); /* register corruption */
47: 47 0002012C fe 04 ef000002f1 callf $4,_sqrtf_3
48: 48 00020133 # sqrtf_4(); /* test the PSL */
49: 49 00020133 fe 04 ef000004d4 callf $4,_sqrtf_4
50: 50 0002013A # sqrtf_5(); /* pipelined entry */
51: 51 0002013A fe 04 ef0000067d callf $4,_sqrtf_5
52: 52 00020141 # sqrtf_6(); /* pipelined exit */
53: 53 00020141 fe 04 ef000007d2 callf $4,_sqrtf_6
54: 54 00020148 # asm("jmp *return"); /* return to the test monitor */
55: 55 00020148 71 ffffffffae jmp *return
56: 56 0002014E # }
57: 57 0002014E 40 ret#2
58: 58 0002014F .set L215,0x0
59: 59 0002014F L217:
60: 60 0002014F 11 af jbr L218
61: 61 00020151 .data
62: 62 00000a60 * .text
63: 63 00020151 00 .align 1
64: 64 00020152 .globl _sqrtf_1
65: 65 00020152 _sqrtf_1:
66: 66 00020152 0000 .word L228
67: 67 00020154 #
68: 68 00020154 # /***************************************************************************
69: 69 00020154 # *
70: 70 00020154 # * SUBTEST 1 - SQUARE-ROOT FUNCTION
71: 71 00020154 # *
72: 72 00020154 # ***************************************************************************/
73: 73 00020154 # sqrtf_1()
74: 74 00020154 # {
75: 75 00020154 13 016a jbr L230
76: 76 00020157 L231:
77: 77 00020157 # #define DELAY 5 /* wait 10 ticks between SQRTF & STF */
78: 78 00020157 # force_loop = FALSE; /* clear the LOOP flag */
79: 79 00020157 4d efffffff9f clrl _force_loop
80: 80 0002015D # subtest = 1;
81: 81 0002015D 0d 01 efffffff98 movl $1,_subtest
82: 82 00020164 # index = 0;
83: 83 00020164 4d efffffff92 clrl _index
84: 84 0002016A # do
85: 85 0002016A L234:
86: 86 0002016A # {
87: 87 0002016A # sgl_ld_acc = sqrtf_1_data[index].ld; /* get the operand */
88: 88 0002016A 0d efffffff8c 50 movl _index,r0
89: 89 00020171 48 03 50 50 shll $3,r0,r0
90: 90 00020175 0d e000000000 efffffff7c movl _sqrtf_1_data(r0),_sgl_ld_acc
91: 91 00020180 # sgl_expected = sqrtf_1_data[index].exp; /* get expected results */
92: 92 00020180 0d efffffff76 50 movl _index,r0
93: 93 00020187 48 03 50 50 shll $3,r0,r0
94: 94 0002018B 0d e000000004 efffffff66 movl _sqrtf_1_data+4(r0),_sgl_expected
95: 95 00020196 # sgl_dummy1 = DELAY;
96: 96 00020196 0d 05 efffffff5f movl $5,_sgl_dummy1
97: 97 0002019D # /*
98: 98 0002019D # * If LOOP ON ERROR is set, this is the loop for this subtest.
99: 99 0002019D # * The force loop flag is set after the first error.
100: 100 0002019D # */
101: 101 0002019D # asm("_sqrtf_1_lp1:");
102: 102 0002019D _sqrtf_1_lp1:
103: 103 0002019D # asm("movl _sgl_ld_acc,r4"); /* set the data to load */
104: 104 0002019D 0d efffffff59 54 movl _sgl_ld_acc,r4
105: 105 000201A4 # asm("ldf r4"); /* load the accumulator */
106: 106 000201A4 06 54 ldf r4
107: 107 000201A6 # asm("movl _sgl_dummy1,r0"); /* get the delay factor */
108: 108 000201A6 0d efffffff50 50 movl _sgl_dummy1,r0
109: 109 000201AD # asm("sqrtf"); /* get ACC.'s square root */
110: 110 000201AD 45 sqrtf
111: 111 000201AE # asm("1:");
112: 112 000201AE 1:
113: 113 000201AE # asm("decl r0"); /* delay to let the SQRTF */
114: 114 000201AE 7d 50 decl r0
115: 115 000201B0 # asm("bgtr 1b"); /* instruction finish */
116: 116 000201B0 41 fc bgtr 1b
117: 117 000201B2 # asm("stf r5"); /* store the result */
118: 118 000201B2 26 55 stf r5
119: 119 000201B4 # if( force_loop )
120: 120 000201B4 5d efffffff42 tstl _force_loop
121: 121 000201BA 31 02 jeql L235
122: 122 000201BC # asm("brb _sqrtf_1_lp1");; /* loop on the error */
123: 123 000201BC 11 df brb _sqrtf_1_lp1
124: 124 000201BE L235:
125: 125 000201BE # /*
126: 126 000201BE # * end error loop
127: 127 000201BE # */
128: 128 000201BE # asm("movl r5,_sgl_st_acc"); /* save the result */
129: 129 000201BE 0d 55 efffffff37 movl r5,_sgl_st_acc
130: 130 000201C5 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
131: 131 000201C5 1d efffffff31 efffffff2c cmpl _sgl_st_acc,_sgl_expected
132: 132 000201D0 21 03 13 00d2 jeql L236
133: 133 000201D5 # {
134: 134 000201D5 # errcnt++; /* bump the error count */
135: 135 000201D5 6d efffffff21 incl _errcnt
136: 136 000201DB # if ( prt_error ) {
137: 137 000201DB 5d efffffff1b tstl _prt_error
138: 138 000201E1 21 03 13 009b jeql L237
139: 139 000201E6 # writes(" \n"); /* start a new print line */
140: 140 000201E6 .data 1
141: 141 00000a67 * L238:
142: 142 00000a67 * 200A00 .ascii " \12\0"
143: 143 00000a6a * .text
144: 144 000201E6 dd 8f00000a67 pushl $L238
145: 145 000201EC fe 08 efffffff09 callf $8,_writes
146: 146 000201F3 # writes("cycle: ");
147: 147 000201F3 .data 1
148: 148 00000a6a * L239:
149: 149 00000a6a * 6379636C653A2000 .ascii "cycle: \0"
150: 150 00000a72 * .text
151: 151 000201F3 dd 8f00000a6a pushl $L239
152: 152 000201F9 fe 08 effffffefc callf $8,_writes
153: 153 00020200 # writed( cycle );
154: 154 00020200 dd effffffef6 pushl _cycle
155: 155 00020206 fe 08 effffffeef callf $8,_writed
156: 156 0002020D # writes(" SQRTF test ");
157: 157 0002020D .data 1
158: 158 00000a72 * L241:
159: 159 00000a72 * 2020535152544620746573742 .ascii " SQRTF test \0"
160: 000
161: 160 00000a80 * .text
162: 161 0002020D dd 8f00000a72 pushl $L241
163: 162 00020213 fe 08 effffffee2 callf $8,_writes
164: 163 0002021A # writed( test_no );
165: 164 0002021A dd effffffedc pushl _test_no
166: 165 00020220 fe 08 effffffed5 callf $8,_writed
167: 166 00020227 # writes(", subtest 1 (delayed store) - BAD FINAL ACC\n");
168: 167 00020227 .data 1
169: 168 00000a80 * L242:
170: 169 00000a80 * 2C20737562746573742031202 .ascii ", subtest 1 (delayed store) - BAD FINAL ACC\12\0"
171: 864656C617965642073746F72
172: 6529202D204241442046494E4
173: 14C204143430A00
174: 170 00000aad * .text
175: 171 00020227 dd 8f00000a80 pushl $L242
176: 172 0002022D fe 08 effffffec8 callf $8,_writes
177: 173 00020234 # print_sqrtf_data();
178: 174 00020234 fe 04 ef0000083b callf $4,_print_sqrtf_data
179: 175 0002023B # writes(", data index = ");
180: 176 0002023B .data 1
181: 177 00000aad * L244:
182: 178 00000aad * 2C20206461746120696E64657 .ascii ", data index = \0"
183: 8203D2000
184: 179 00000abe * .text
185: 180 0002023B dd 8f00000aad pushl $L244
186: 181 00020241 fe 08 effffffeb4 callf $8,_writes
187: 182 00020248 # writed( index );
188: 183 00020248 dd effffffeae pushl _index
189: 184 0002024E fe 08 effffffea7 callf $8,_writed
190: 185 00020255 # writec('\n');
191: 186 00020255 dd 0a pushl $10
192: 187 00020257 fe 08 effffffe9e callf $8,_writec
193: 188 0002025E # writes(" Acc expected = ");
194: 189 0002025E .data 1
195: 190 00000abe * L246:
196: 191 00000abe * 2020202020202020202020202 .ascii " Acc expected = \0"
197: 0202020202020202020416363
198: 206578706563746564203D200
199: 0
200: 192 00000ae4 * .text
201: 193 0002025E dd 8f00000abe pushl $L246
202: 194 00020264 fe 08 effffffe91 callf $8,_writes
203: 195 0002026B # write32h( sgl_expected );
204: 196 0002026B dd effffffe8b pushl _sgl_expected
205: 197 00020271 fe 08 effffffe84 callf $8,_write32h
206: 198 00020278 # writec('\n');
207: 199 00020278 dd 0a pushl $10
208: 200 0002027A fe 08 effffffe7b callf $8,_writec
209: 201 00020281 # }
210: 202 00020281 # if ( halt_flg ) /* halt on error? */
211: 203 00020281 L237:
212: 204 00020281 5d effffffe75 tstl _halt_flg
213: 205 00020287 31 09 jeql L248
214: 206 00020289 # sqrtf_er_halt( BAD_ACC_HLT );
215: 207 00020289 dd 01 pushl $1
216: 208 0002028B fe 08 ef00000820 callf $8,_sqrtf_er_halt
217: 209 00020292 # if ( loop_on_err )
218: 210 00020292 L248:
219: 211 00020292 5d effffffe64 tstl _loop_on_err
220: 212 00020298 31 0d jeql L250
221: 213 0002029A # {
222: 214 0002029A # force_loop = TRUE; /* set the force loop flag */
223: 215 0002029A 0d 01 effffffe5b movl $1,_force_loop
224: 216 000202A1 # asm("jmp _sqrtf_1_lp1"); /* and loop */
225: 217 000202A1 71 effffffef6 jmp _sqrtf_1_lp1
226: 218 000202A7 # }
227: 219 000202A7 # } /* end of compare error */
228: 220 000202A7 L250:
229: 221 000202A7 # } while( index++ < max_sqrtf_1_index );
230: 222 000202A7 L236:
231: 223 000202A7 L233:
232: 224 000202A7 0d effffffe4f 50 movl _index,r0
233: 225 000202AE 6d effffffe48 incl _index
234: 226 000202B4 1d 50 effffffe41 cmpl r0,_max_sqrtf_1_index
235: 227 000202BB 81 03 13 feaa jlss L234
236: 228 000202C0 L232:
237: 229 000202C0 # } /* end of subtest 1 */
238: 230 000202C0 40 ret#2
239: 231 000202C1 .set L228,0x0
240: 232 000202C1 L230:
241: 233 000202C1 13 fe93 jbr L231
242: 234 000202C4 .data
243: 235 00000a60 * .text
244: 236 000202C4 .align 1
245: 237 000202C4 .globl _sqrtf_2
246: 238 000202C4 _sqrtf_2:
247: 239 000202C4 0000 .word L251
248: 240 000202C6 #
249: 241 000202C6 #
250: 242 000202C6 #
251: 243 000202C6 # /***************************************************************************
252: 244 000202C6 # *
253: 245 000202C6 # * SUBTEST 2 - SQUARE-ROOT FUNCTION
254: 246 000202C6 # *
255: 247 000202C6 # ***************************************************************************/
256: 248 000202C6 # sqrtf_2()
257: 249 000202C6 # {
258: 250 000202C6 13 0158 jbr L253
259: 251 000202C9 L254:
260: 252 000202C9 # force_loop = FALSE; /* clear the LOOP flag */
261: 253 000202C9 4d effffffe2d clrl _force_loop
262: 254 000202CF # subtest = 2;
263: 255 000202CF 0d 02 effffffe26 movl $2,_subtest
264: 256 000202D6 # index = 0;
265: 257 000202D6 4d effffffe20 clrl _index
266: 258 000202DC # do
267: 259 000202DC L257:
268: 260 000202DC # {
269: 261 000202DC # sgl_ld_acc = sqrtf_1_data[index].ld; /* get the operand */
270: 262 000202DC 0d effffffe1a 50 movl _index,r0
271: 263 000202E3 48 03 50 50 shll $3,r0,r0
272: 264 000202E7 0d e000000000 effffffe0a movl _sqrtf_1_data(r0),_sgl_ld_acc
273: 265 000202F2 # sgl_expected = sqrtf_1_data[index].exp; /* get expected results */
274: 266 000202F2 0d effffffe04 50 movl _index,r0
275: 267 000202F9 48 03 50 50 shll $3,r0,r0
276: 268 000202FD 0d e000000004 effffffdf4 movl _sqrtf_1_data+4(r0),_sgl_expected
277: 269 00020308 # /*
278: 270 00020308 # * If LOOP ON ERROR is set, this is the loop for this subtest.
279: 271 00020308 # * The force loop flag is set after the first error.
280: 272 00020308 # */
281: 273 00020308 # asm("_sqrtf_2_lp1:");
282: 274 00020308 _sqrtf_2_lp1:
283: 275 00020308 # asm("movl _sgl_ld_acc,r4"); /* set the data to load */
284: 276 00020308 0d effffffdee 54 movl _sgl_ld_acc,r4
285: 277 0002030F # asm("ldf r4"); /* load the accumulator */
286: 278 0002030F 06 54 ldf r4
287: 279 00020311 # asm("sqrtf"); /* get ACC.'s square root */
288: 280 00020311 45 sqrtf
289: 281 00020312 # asm("stf r5"); /* store the result */
290: 282 00020312 26 55 stf r5
291: 283 00020314 # if( force_loop )
292: 284 00020314 5d effffffde2 tstl _force_loop
293: 285 0002031A 31 02 jeql L258
294: 286 0002031C # asm("brb _sqrtf_2_lp1");; /* loop on the error */
295: 287 0002031C 11 ea brb _sqrtf_2_lp1
296: 288 0002031E L258:
297: 289 0002031E # /*
298: 290 0002031E # * end error loop
299: 291 0002031E # */
300: 292 0002031E # asm("movl r5,_sgl_st_acc"); /* save the result */
301: 293 0002031E 0d 55 effffffdd7 movl r5,_sgl_st_acc
302: 294 00020325 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
303: 295 00020325 1d effffffdd1 effffffdcc cmpl _sgl_st_acc,_sgl_expected
304: 296 00020330 21 03 13 00d2 jeql L259
305: 297 00020335 # {
306: 298 00020335 # errcnt++; /* bump the error count */
307: 299 00020335 6d effffffdc1 incl _errcnt
308: 300 0002033B # if ( prt_error ) {
309: 301 0002033B 5d effffffdbb tstl _prt_error
310: 302 00020341 21 03 13 009b jeql L260
311: 303 00020346 # writes(" \n"); /* start a new print line */
312: 304 00020346 .data 1
313: 305 00000ae4 * L261:
314: 306 00000ae4 * 200A00 .ascii " \12\0"
315: 307 00000ae7 * .text
316: 308 00020346 dd 8f00000ae4 pushl $L261
317: 309 0002034C fe 08 effffffda9 callf $8,_writes
318: 310 00020353 # writes("cycle: ");
319: 311 00020353 .data 1
320: 312 00000ae7 * L262:
321: 313 00000ae7 * 6379636C653A2000 .ascii "cycle: \0"
322: 314 00000aef * .text
323: 315 00020353 dd 8f00000ae7 pushl $L262
324: 316 00020359 fe 08 effffffd9c callf $8,_writes
325: 317 00020360 # writed( cycle );
326: 318 00020360 dd effffffd96 pushl _cycle
327: 319 00020366 fe 08 effffffd8f callf $8,_writed
328: 320 0002036D # writes(" SQRTF test ");
329: 321 0002036D .data 1
330: 322 00000aef * L263:
331: 323 00000aef * 2020535152544620746573742 .ascii " SQRTF test \0"
332: 000
333: 324 00000afd * .text
334: 325 0002036D dd 8f00000aef pushl $L263
335: 326 00020373 fe 08 effffffd82 callf $8,_writes
336: 327 0002037A # writed( test_no );
337: 328 0002037A dd effffffd7c pushl _test_no
338: 329 00020380 fe 08 effffffd75 callf $8,_writed
339: 330 00020387 # writes(", subtest 2 (immediate store) - BAD FINAL ACC\n");
340: 331 00020387 .data 1
341: 332 00000afd * L264:
342: 333 00000afd * 2C20737562746573742032202 .ascii ", subtest 2 (immediate store) - BAD FINAL ACC\12\0"
343: 8696D6D656469617465207374
344: 6F726529202D2042414420464
345: 94E414C204143430A00
346: 334 00000b2c * .text
347: 335 00020387 dd 8f00000afd pushl $L264
348: 336 0002038D fe 08 effffffd68 callf $8,_writes
349: 337 00020394 # print_sqrtf_data();
350: 338 00020394 fe 04 ef000006db callf $4,_print_sqrtf_data
351: 339 0002039B # writes(", data index = ");
352: 340 0002039B .data 1
353: 341 00000b2c * L265:
354: 342 00000b2c * 2C20206461746120696E64657 .ascii ", data index = \0"
355: 8203D2000
356: 343 00000b3d * .text
357: 344 0002039B dd 8f00000b2c pushl $L265
358: 345 000203A1 fe 08 effffffd54 callf $8,_writes
359: 346 000203A8 # writed( index );
360: 347 000203A8 dd effffffd4e pushl _index
361: 348 000203AE fe 08 effffffd47 callf $8,_writed
362: 349 000203B5 # writec('\n');
363: 350 000203B5 dd 0a pushl $10
364: 351 000203B7 fe 08 effffffd3e callf $8,_writec
365: 352 000203BE # writes(" Acc expected = ");
366: 353 000203BE .data 1
367: 354 00000b3d * L266:
368: 355 00000b3d * 2020202020202020202020202 .ascii " Acc expected = \0"
369: 0202020202020202020416363
370: 206578706563746564203D200
371: 0
372: 356 00000b63 * .text
373: 357 000203BE dd 8f00000b3d pushl $L266
374: 358 000203C4 fe 08 effffffd31 callf $8,_writes
375: 359 000203CB # write32h( sgl_expected );
376: 360 000203CB dd effffffd2b pushl _sgl_expected
377: 361 000203D1 fe 08 effffffd24 callf $8,_write32h
378: 362 000203D8 # writec('\n');
379: 363 000203D8 dd 0a pushl $10
380: 364 000203DA fe 08 effffffd1b callf $8,_writec
381: 365 000203E1 # }
382: 366 000203E1 # if ( halt_flg ) /* halt on error? */
383: 367 000203E1 L260:
384: 368 000203E1 5d effffffd15 tstl _halt_flg
385: 369 000203E7 31 09 jeql L267
386: 370 000203E9 # sqrtf_er_halt( BAD_ACC_HLT );
387: 371 000203E9 dd 01 pushl $1
388: 372 000203EB fe 08 ef000006c0 callf $8,_sqrtf_er_halt
389: 373 000203F2 # if ( loop_on_err )
390: 374 000203F2 L267:
391: 375 000203F2 5d effffffd04 tstl _loop_on_err
392: 376 000203F8 31 0d jeql L268
393: 377 000203FA # {
394: 378 000203FA # force_loop = TRUE; /* set the force loop flag */
395: 379 000203FA 0d 01 effffffcfb movl $1,_force_loop
396: 380 00020401 # asm("jmp _sqrtf_2_lp1"); /* and loop */
397: 381 00020401 71 efffffff01 jmp _sqrtf_2_lp1
398: 382 00020407 # }
399: 383 00020407 # } /* end of compare error */
400: 384 00020407 L268:
401: 385 00020407 # } while( index++ < max_sqrtf_1_index );
402: 386 00020407 L259:
403: 387 00020407 L256:
404: 388 00020407 0d effffffcef 50 movl _index,r0
405: 389 0002040E 6d effffffce8 incl _index
406: 390 00020414 1d 50 effffffce1 cmpl r0,_max_sqrtf_1_index
407: 391 0002041B 81 03 13 febc jlss L257
408: 392 00020420 L255:
409: 393 00020420 # } /* end of subtest 2 */
410: 394 00020420 40 ret#2
411: 395 00020421 .set L251,0x0
412: 396 00020421 L253:
413: 397 00020421 13 fea5 jbr L254
414: 398 00020424 .data
415: 399 00000a60 * .text
416: 400 00020424 .align 1
417: 401 00020424 .globl _sqrtf_3
418: 402 00020424 _sqrtf_3:
419: 403 00020424 0000 .word L269
420: 404 00020426 #
421: 405 00020426 #
422: 406 00020426 #
423: 407 00020426 # /***************************************************************************
424: 408 00020426 # *
425: 409 00020426 # * SUBTEST 3 - REGISTER INTEGRITY WITH THE SQRTF FUNCTION
426: 410 00020426 # *
427: 411 00020426 # ***************************************************************************/
428: 412 00020426 # sqrtf_3()
429: 413 00020426 # {
430: 414 00020426 13 01e1 jbr L271
431: 415 00020429 L272:
432: 416 00020429 # fill_reg_buf( load_regs ); /* set reg values to load */
433: 417 00020429 dd 8f00000000 pushl $_load_regs
434: 418 0002042F fe 08 effffffcc6 callf $8,_fill_reg_buf
435: 419 00020436 # force_loop = FALSE; /* clear the LOOP flag */
436: 420 00020436 4d effffffcc0 clrl _force_loop
437: 421 0002043C # subtest = 3;
438: 422 0002043C 0d 03 effffffcb9 movl $3,_subtest
439: 423 00020443 # index = 0;
440: 424 00020443 4d effffffcb3 clrl _index
441: 425 00020449 # do
442: 426 00020449 L276:
443: 427 00020449 # {
444: 428 00020449 # sgl_ld_acc = sqrtf_1_data[index].ld; /* get the operand */
445: 429 00020449 0d effffffcad 50 movl _index,r0
446: 430 00020450 48 03 50 50 shll $3,r0,r0
447: 431 00020454 0d e000000000 effffffc9d movl _sqrtf_1_data(r0),_sgl_ld_acc
448: 432 0002045F # sgl_expected = sqrtf_1_data[index].exp; /* get expected results */
449: 433 0002045F 0d effffffc97 50 movl _index,r0
450: 434 00020466 48 03 50 50 shll $3,r0,r0
451: 435 0002046A 0d e000000004 effffffc87 movl _sqrtf_1_data+4(r0),_sgl_expected
452: 436 00020475 # /*
453: 437 00020475 # * If LOOP ON ERROR is set, this is the loop for this subtest.
454: 438 00020475 # * The force loop flag is set after the first error.
455: 439 00020475 # */
456: 440 00020475 # asm("_sqrtf_3_lp1:");
457: 441 00020475 _sqrtf_3_lp1:
458: 442 00020475 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
459: 443 00020475 ab 891fff effffffc7e loadr $0x1fff,_load_regs
460: 444 0002047E # asm("ldf _sgl_ld_acc"); /* load the accumulator */
461: 445 0002047E 06 effffffc78 ldf _sgl_ld_acc
462: 446 00020484 # asm("sqrtf"); /* get ACC.'s sqrt */
463: 447 00020484 45 sqrtf
464: 448 00020485 # asm("stf _sgl_st_acc"); /* store the result */
465: 449 00020485 26 effffffc71 stf _sgl_st_acc
466: 450 0002048B # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
467: 451 0002048B bb 891fff effffffc68 storer $0x1fff,_store_regs
468: 452 00020494 # if( force_loop )
469: 453 00020494 5d effffffc62 tstl _force_loop
470: 454 0002049A 31 02 jeql L277
471: 455 0002049C # asm("brb _sqrtf_3_lp1");; /* loop on the error */
472: 456 0002049C 11 d7 brb _sqrtf_3_lp1
473: 457 0002049E L277:
474: 458 0002049E # /*
475: 459 0002049E # * end error loop
476: 460 0002049E # */
477: 461 0002049E # reg_no = 0;
478: 462 0002049E 4d effffffc58 clrl _reg_no
479: 463 000204A4 # regs_ok = TRUE;
480: 464 000204A4 0d 01 effffffc51 movl $1,_regs_ok
481: 465 000204AB # while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */
482: 466 000204AB L278:
483: 467 000204AB 1d effffffc4b 0d cmpl _reg_no,$13
484: 468 000204B2 81 35 jgeq L279
485: 469 000204B4 5d effffffc42 tstl _regs_ok
486: 470 000204BA 31 2d jeql L279
487: 471 000204BC # if( store_regs[ reg_no ] == load_regs[ reg_no ] )
488: 472 000204BC 0d effffffc3a 50 movl _reg_no,r0
489: 473 000204C3 0d effffffc33 51 movl _reg_no,r1
490: 474 000204CA 1d 40effffffc2b cmpl _store_regs[r0],_load_regs[r1]
491: 41effffffc25
492: 475 000204D7 21 08 jneq L280
493: 476 000204D9 # reg_no++;
494: 477 000204D9 6d effffffc1d incl _reg_no
495: 478 000204DF # else
496: 479 000204DF 11 06 jbr L281
497: 480 000204E1 L280:
498: 481 000204E1 # regs_ok = FALSE;
499: 482 000204E1 4d effffffc15 clrl _regs_ok
500: 483 000204E7 L281:
501: 484 000204E7 11 c2 jbr L278
502: 485 000204E9 L279:
503: 486 000204E9 # if( !regs_ok )
504: 487 000204E9 5d effffffc0d tstl _regs_ok
505: 488 000204EF 31 03 13 00fc jneq L282
506: 489 000204F4 # {
507: 490 000204F4 # errcnt++; /* bump the error count */
508: 491 000204F4 6d effffffc02 incl _errcnt
509: 492 000204FA # if ( prt_error ) {
510: 493 000204FA 5d effffffbfc tstl _prt_error
511: 494 00020500 21 03 13 00eb jeql L283
512: 495 00020505 # writes(" \n"); /* start a new print line */
513: 496 00020505 .data 1
514: 497 00000b63 * L284:
515: 498 00000b63 * 200A00 .ascii " \12\0"
516: 499 00000b66 * .text
517: 500 00020505 dd 8f00000b63 pushl $L284
518: 501 0002050B fe 08 effffffbea callf $8,_writes
519: 502 00020512 # writes("cycle: ");
520: 503 00020512 .data 1
521: 504 00000b66 * L285:
522: 505 00000b66 * 6379636C653A2000 .ascii "cycle: \0"
523: 506 00000b6e * .text
524: 507 00020512 dd 8f00000b66 pushl $L285
525: 508 00020518 fe 08 effffffbdd callf $8,_writes
526: 509 0002051F # writed( cycle );
527: 510 0002051F dd effffffbd7 pushl _cycle
528: 511 00020525 fe 08 effffffbd0 callf $8,_writed
529: 512 0002052C # writes(" SQRTF test ");
530: 513 0002052C .data 1
531: 514 00000b6e * L286:
532: 515 00000b6e * 2020535152544620746573742 .ascii " SQRTF test \0"
533: 000
534: 516 00000b7c * .text
535: 517 0002052C dd 8f00000b6e pushl $L286
536: 518 00020532 fe 08 effffffbc3 callf $8,_writes
537: 519 00020539 # writed( test_no );
538: 520 00020539 dd effffffbbd pushl _test_no
539: 521 0002053F fe 08 effffffbb6 callf $8,_writed
540: 522 00020546 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); {
541: 523 00020546 .data 1
542: 524 00000b7c * L287:
543: 525 00000b7c * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0"
544: D204120524547495354455220
545: 574153204D4F4449464945440
546: A00
547: 526 00000ba3 * .text
548: 527 00020546 dd 8f00000b7c pushl $L287
549: 528 0002054C fe 08 effffffba9 callf $8,_writes
550: 529 00020553 # print_sqrtf_data();
551: 530 00020553 fe 04 ef0000051c callf $4,_print_sqrtf_data
552: 531 0002055A # writec('\n');
553: 532 0002055A dd 0a pushl $10
554: 533 0002055C fe 08 effffffb99 callf $8,_writec
555: 534 00020563 # writes("register ");
556: 535 00020563 .data 1
557: 536 00000ba3 * L288:
558: 537 00000ba3 * 72656769737465722000 .ascii "register \0"
559: 538 00000bad * .text
560: 539 00020563 dd 8f00000ba3 pushl $L288
561: 540 00020569 fe 08 effffffb8c callf $8,_writes
562: 541 00020570 # writed( reg_no );
563: 542 00020570 dd effffffb86 pushl _reg_no
564: 543 00020576 fe 08 effffffb7f callf $8,_writed
565: 544 0002057D # writes(" = ");
566: 545 0002057D .data 1
567: 546 00000bad * L289:
568: 547 00000bad * 203D2000 .ascii " = \0"
569: 548 00000bb1 * .text
570: 549 0002057D dd 8f00000bad pushl $L289
571: 550 00020583 fe 08 effffffb72 callf $8,_writes
572: 551 0002058A # write32h( load_regs[reg_no] );
573: 552 0002058A 0d effffffb6c 50 movl _reg_no,r0
574: 553 00020591 dd 40effffffb64 pushl _load_regs[r0]
575: 554 00020598 fe 08 effffffb5d callf $8,_write32h
576: 555 0002059F # writes(", should be = ");
577: 556 0002059F .data 1
578: 557 00000bb1 * L290:
579: 558 00000bb1 * 2C202073686F756C642062652 .ascii ", should be = \0"
580: 03D2000
581: 559 00000bc1 * .text
582: 560 0002059F dd 8f00000bb1 pushl $L290
583: 561 000205A5 fe 08 effffffb50 callf $8,_writes
584: 562 000205AC # write32h( store_regs[reg_no] );
585: 563 000205AC 0d effffffb4a 50 movl _reg_no,r0
586: 564 000205B3 dd 40effffffb42 pushl _store_regs[r0]
587: 565 000205BA fe 08 effffffb3b callf $8,_write32h
588: 566 000205C1 # writec('\n');
589: 567 000205C1 dd 0a pushl $10
590: 568 000205C3 fe 08 effffffb32 callf $8,_writec
591: 569 000205CA # }
592: 570 000205CA # if ( halt_flg ) /* halt on error? */
593: 571 000205CA 5d effffffb2c tstl _halt_flg
594: 572 000205D0 31 09 jeql L291
595: 573 000205D2 # sqrtf_er_halt( BAD_REG_HLT );
596: 574 000205D2 dd 02 pushl $2
597: 575 000205D4 fe 08 ef000004d7 callf $8,_sqrtf_er_halt
598: 576 000205DB # if ( loop_on_err )
599: 577 000205DB L291:
600: 578 000205DB 5d effffffb1b tstl _loop_on_err
601: 579 000205E1 31 0d jeql L292
602: 580 000205E3 # {
603: 581 000205E3 # force_loop = TRUE; /* get the force loop flag */
604: 582 000205E3 0d 01 effffffb12 movl $1,_force_loop
605: 583 000205EA # asm("jmp _sqrtf_3_lp1"); /* and loop */
606: 584 000205EA 71 effffffe85 jmp _sqrtf_3_lp1
607: 585 000205F0 # }
608: 586 000205F0 # } /* end of compare error */
609: 587 000205F0 L292:
610: 588 000205F0 # } /* end of while loop */
611: 589 000205F0 L283:
612: 590 000205F0 # } while( index++ < max_sqrtf_1_index );
613: 591 000205F0 L282:
614: 592 000205F0 L275:
615: 593 000205F0 0d effffffb06 50 movl _index,r0
616: 594 000205F7 6d effffffaff incl _index
617: 595 000205FD 1d 50 effffffaf8 cmpl r0,_max_sqrtf_1_index
618: 596 00020604 81 03 13 fe40 jlss L276
619: 597 00020609 L274:
620: 598 00020609 # } /* end of subtest 3 */
621: 599 00020609 40 ret#2
622: 600 0002060A .set L269,0x0
623: 601 0002060A L271:
624: 602 0002060A 13 fe1c jbr L272
625: 603 0002060D .data
626: 604 00000a60 * .text
627: 605 0002060D 00 .align 1
628: 606 0002060E .globl _sqrtf_4
629: 607 0002060E _sqrtf_4:
630: 608 0002060E 0000 .word L293
631: 609 00020610 #
632: 610 00020610 #
633: 611 00020610 #
634: 612 00020610 # /************************************************************************
635: 613 00020610 # *
636: 614 00020610 # * SUBTEST 4 - Check for PSL corruption
637: 615 00020610 # *
638: 616 00020610 # ************************************************************************/
639: 617 00020610 # sqrtf_4()
640: 618 00020610 # {
641: 619 00020610 13 01a8 jbr L295
642: 620 00020613 L296:
643: 621 00020613 # force_loop = FALSE; /* clear force_loop flg */
644: 622 00020613 4d effffffae3 clrl _force_loop
645: 623 00020619 # subtest = 4;
646: 624 00020619 0d 04 effffffadc movl $4,_subtest
647: 625 00020620 # fill_reg_buf( load_regs ); /* get patterns for regs */
648: 626 00020620 dd 8f00000000 pushl $_load_regs
649: 627 00020626 fe 08 effffffacf callf $8,_fill_reg_buf
650: 628 0002062D # for( index = 0; index < 3; index++ ) {
651: 629 0002062D 4d effffffac9 clrl _index
652: 630 00020633 L299:
653: 631 00020633 1d effffffac3 03 cmpl _index,$3
654: 632 0002063A 91 03 13 017b jgeq L298
655: 633 0002063F # sgl_ld_acc = sqrtf_1_data[index].ld; /* get operand 1 */
656: 634 0002063F 0d effffffab7 50 movl _index,r0
657: 635 00020646 48 03 50 50 shll $3,r0,r0
658: 636 0002064A 0d e000000000 effffffaa7 movl _sqrtf_1_data(r0),_sgl_ld_acc
659: 637 00020655 # sgl_expected = sqrtf_1_data[index].exp; /* get expected */
660: 638 00020655 0d effffffaa1 50 movl _index,r0
661: 639 0002065C 48 03 50 50 shll $3,r0,r0
662: 640 00020660 0d e000000004 effffffa91 movl _sqrtf_1_data+4(r0),_sgl_expected
663: 641 0002066B # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
664: 642 0002066B 0d effffffa8b 50 movl _status_index,r0
665: 643 00020672 0d 40effffffa83 movl _status_array[r0],_sgl_dummy1
666: effffffa7e
667: 644 0002067E # /*
668: 645 0002067E # * If LOOP ON ERROR is set, this is the loop for this subtest.
669: 646 0002067E # * The force loop flag is set after the first error.
670: 647 0002067E # */
671: 648 0002067E # asm("_sqrtf_4_lp1:");
672: 649 0002067E _sqrtf_4_lp1:
673: 650 0002067E # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
674: 651 0002067E 06 effffffa78 ldf _sgl_ld_acc
675: 652 00020684 # asm("nop");
676: 653 00020684 10 nop
677: 654 00020685 # asm("tstl _sgl_dummy1"); /* set the PSL status */
678: 655 00020685 5d effffffa71 tstl _sgl_dummy1
679: 656 0002068B # asm("movpsl _init_psl"); /* save the initial PSL */
680: 657 0002068B cd effffffa6b movpsl _init_psl
681: 658 00020691 # asm("sqrtf"); /* do the sqrt */
682: 659 00020691 45 sqrtf
683: 660 00020692 # asm("nop");
684: 661 00020692 10 nop
685: 662 00020693 # asm("movpsl _psl_val"); /* save the final PSL */
686: 663 00020693 cd effffffa63 movpsl _psl_val
687: 664 00020699 # asm("stf _sgl_st_acc"); /* save the accumulator */
688: 665 00020699 26 effffffa5d stf _sgl_st_acc
689: 666 0002069F # if( force_loop )
690: 667 0002069F 5d effffffa57 tstl _force_loop
691: 668 000206A5 31 02 jeql L300
692: 669 000206A7 # asm("brb _sqrtf_4_lp1");; /* loop on the error */
693: 670 000206A7 11 d5 brb _sqrtf_4_lp1
694: 671 000206A9 L300:
695: 672 000206A9 # /*
696: 673 000206A9 # * Now compare the final PSL to the initial PSL -they should be the same
697: 674 000206A9 # */
698: 675 000206A9 # exp_psl = init_psl;
699: 676 000206A9 0d effffffa4d effffffa48 movl _init_psl,_exp_psl
700: 677 000206B4 # if( psl_val != exp_psl ) {
701: 678 000206B4 1d effffffa42 effffffa3d cmpl _psl_val,_exp_psl
702: 679 000206BF 21 03 13 00ed jeql L301
703: 680 000206C4 # errcnt++; /* bump the error count */
704: 681 000206C4 6d effffffa32 incl _errcnt
705: 682 000206CA # if( prt_error ) {
706: 683 000206CA 5d effffffa2c tstl _prt_error
707: 684 000206D0 21 03 13 00b9 jeql L302
708: 685 000206D5 # writes(" \n"); /* start a new print line */
709: 686 000206D5 .data 1
710: 687 00000bc1 * L303:
711: 688 00000bc1 * 200A00 .ascii " \12\0"
712: 689 00000bc4 * .text
713: 690 000206D5 dd 8f00000bc1 pushl $L303
714: 691 000206DB fe 08 effffffa1a callf $8,_writes
715: 692 000206E2 # writes("cycle: ");
716: 693 000206E2 .data 1
717: 694 00000bc4 * L304:
718: 695 00000bc4 * 6379636C653A2000 .ascii "cycle: \0"
719: 696 00000bcc * .text
720: 697 000206E2 dd 8f00000bc4 pushl $L304
721: 698 000206E8 fe 08 effffffa0d callf $8,_writes
722: 699 000206EF # writed( cycle );
723: 700 000206EF dd effffffa07 pushl _cycle
724: 701 000206F5 fe 08 effffffa00 callf $8,_writed
725: 702 000206FC # writes(" SQRTF test ");
726: 703 000206FC .data 1
727: 704 00000bcc * L305:
728: 705 00000bcc * 2020535152544620746573742 .ascii " SQRTF test \0"
729: 000
730: 706 00000bda * .text
731: 707 000206FC dd 8f00000bcc pushl $L305
732: 708 00020702 fe 08 effffff9f3 callf $8,_writes
733: 709 00020709 # writed( test_no );
734: 710 00020709 dd effffff9ed pushl _test_no
735: 711 0002070F fe 08 effffff9e6 callf $8,_writed
736: 712 00020716 # writes(", subtest 4 - INCORRECT FINAL PSL\n");
737: 713 00020716 .data 1
738: 714 00000bda * L306:
739: 715 00000bda * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0"
740: D20494E434F52524543542046
741: 494E414C2050534C0A00
742: 716 00000bfd * .text
743: 717 00020716 dd 8f00000bda pushl $L306
744: 718 0002071C fe 08 effffff9d9 callf $8,_writes
745: 719 00020723 # print_sqrtf_data(); /* print the operands */
746: 720 00020723 fe 04 ef0000034c callf $4,_print_sqrtf_data
747: 721 0002072A # writec('\n');
748: 722 0002072A dd 0a pushl $10
749: 723 0002072C fe 08 effffff9c9 callf $8,_writec
750: 724 00020733 # writes("initial PSL = ");
751: 725 00020733 .data 1
752: 726 00000bfd * L307:
753: 727 00000bfd * 696E697469616C2050534C203 .ascii "initial PSL = \0"
754: D2000
755: 728 00000c0c * .text
756: 729 00020733 dd 8f00000bfd pushl $L307
757: 730 00020739 fe 08 effffff9bc callf $8,_writes
758: 731 00020740 # write32h( init_psl );
759: 732 00020740 dd effffff9b6 pushl _init_psl
760: 733 00020746 fe 08 effffff9af callf $8,_write32h
761: 734 0002074D # writes(", final PSL = ");
762: 735 0002074D .data 1
763: 736 00000c0c * L308:
764: 737 00000c0c * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
765: 03D2000
766: 738 00000c1c * .text
767: 739 0002074D dd 8f00000c0c pushl $L308
768: 740 00020753 fe 08 effffff9a2 callf $8,_writes
769: 741 0002075A # write32h( psl_val );
770: 742 0002075A dd effffff99c pushl _psl_val
771: 743 00020760 fe 08 effffff995 callf $8,_write32h
772: 744 00020767 # writes(", expected PSL = ");
773: 745 00020767 .data 1
774: 746 00000c1c * L309:
775: 747 00000c1c * 2C20206578706563746564205 .ascii ", expected PSL = \0"
776: 0534C203D2000
777: 748 00000c2f * .text
778: 749 00020767 dd 8f00000c1c pushl $L309
779: 750 0002076D fe 08 effffff988 callf $8,_writes
780: 751 00020774 # write32h( exp_psl );
781: 752 00020774 dd effffff982 pushl _exp_psl
782: 753 0002077A fe 08 effffff97b callf $8,_write32h
783: 754 00020781 # writes("\n");
784: 755 00020781 .data 1
785: 756 00000c2f * L310:
786: 757 00000c2f * 0A00 .ascii "\12\0"
787: 758 00000c31 * .text
788: 759 00020781 dd 8f00000c2f pushl $L310
789: 760 00020787 fe 08 effffff96e callf $8,_writes
790: 761 0002078E # }
791: 762 0002078E # if( halt_flg )
792: 763 0002078E L302:
793: 764 0002078E 5d effffff968 tstl _halt_flg
794: 765 00020794 31 09 jeql L311
795: 766 00020796 # sqrtf_er_halt( BAD_PSL_HLT ); /* halt on the error */
796: 767 00020796 dd 03 pushl $3
797: 768 00020798 fe 08 ef00000313 callf $8,_sqrtf_er_halt
798: 769 0002079F # if( loop_on_err ) {
799: 770 0002079F L311:
800: 771 0002079F 5d effffff957 tstl _loop_on_err
801: 772 000207A5 31 0a jeql L312
802: 773 000207A7 # force_loop = TRUE; /* set the force loop flag */
803: 774 000207A7 0d 01 effffff94e movl $1,_force_loop
804: 775 000207AE # asm("brw _sqrtf_4_lp1");; /* and loop on the error */
805: 776 000207AE 13 fecd brw _sqrtf_4_lp1
806: 777 000207B1 # } /* end of loop on error */
807: 778 000207B1 # } /* end of PSL corruption error */
808: 779 000207B1 L312:
809: 780 000207B1 # } /* end of WHILE loop */
810: 781 000207B1 L301:
811: 782 000207B1 L297:
812: 783 000207B1 6d effffff945 incl _index
813: 784 000207B7 13 fe79 jbr L299
814: 785 000207BA L298:
815: 786 000207BA # } /* end of subtest 4 */
816: 787 000207BA 40 ret#2
817: 788 000207BB .set L293,0x0
818: 789 000207BB L295:
819: 790 000207BB 13 fe55 jbr L296
820: 791 000207BE .data
821: 792 00000a60 * .text
822: 793 000207BE .align 1
823: 794 000207BE .globl _sqrtf_5
824: 795 000207BE _sqrtf_5:
825: 796 000207BE 0000 .word L313
826: 797 000207C0 #
827: 798 000207C0 #
828: 799 000207C0 #
829: 800 000207C0 # /************************************************************************
830: 801 000207C0 # *
831: 802 000207C0 # * SUBTEST 5 - pipelined entry test
832: 803 000207C0 # *
833: 804 000207C0 # ************************************************************************/
834: 805 000207C0 # sqrtf_5()
835: 806 000207C0 # {
836: 807 000207C0 13 0154 jbr L315
837: 808 000207C3 L316:
838: 809 000207C3 # force_loop = FALSE;
839: 810 000207C3 4d effffff933 clrl _force_loop
840: 811 000207C9 # subtest = 8;
841: 812 000207C9 0d 08 effffff92c movl $8,_subtest
842: 813 000207D0 # for( index = 0; index < max_sqrtf_1_index; index++ ) {
843: 814 000207D0 4d effffff926 clrl _index
844: 815 000207D6 L319:
845: 816 000207D6 1d effffff920 effffff91b cmpl _index,_max_sqrtf_1_index
846: 817 000207E1 91 03 13 0130 jgeq L318
847: 818 000207E6 # sgl_ld_acc = sqrtf_1_data[index].ld; /* get operand 1 */
848: 819 000207E6 0d effffff910 50 movl _index,r0
849: 820 000207ED 48 03 50 50 shll $3,r0,r0
850: 821 000207F1 0d e000000000 effffff900 movl _sqrtf_1_data(r0),_sgl_ld_acc
851: 822 000207FC # sgl_expected = sqrtf_1_data[index].exp; /* get expected result */
852: 823 000207FC 0d effffff8fa 50 movl _index,r0
853: 824 00020803 48 03 50 50 shll $3,r0,r0
854: 825 00020807 0d e000000004 effffff8ea movl _sqrtf_1_data+4(r0),_sgl_expected
855: 826 00020812 # /*
856: 827 00020812 # * If LOOP ON ERROR is set, this is the loop for this subtest.
857: 828 00020812 # * The force loop flag is set after the first error.
858: 829 00020812 # */
859: 830 00020812 # asm("_sqrtf_5_lp1:");
860: 831 00020812 _sqrtf_5_lp1:
861: 832 00020812 # asm("movl $0,r0"); /* clear r0 */
862: 833 00020812 0d 00 50 movl $0,r0
863: 834 00020815 # asm("ldf r0"); /* load the Acc. with 0.0 */
864: 835 00020815 06 50 ldf r0
865: 836 00020817 # asm("addf _sgl_ld_acc"); /* add the 1st operand */
866: 837 00020817 c6 effffff8df addf _sgl_ld_acc
867: 838 0002081D # asm("sqrtf"); /* get the sqrt */
868: 839 0002081D 45 sqrtf
869: 840 0002081E # asm("stf _sgl_st_acc"); /* store the result */
870: 841 0002081E 26 effffff8d8 stf _sgl_st_acc
871: 842 00020824 # if( force_loop )
872: 843 00020824 5d effffff8d2 tstl _force_loop
873: 844 0002082A 31 02 jeql L320
874: 845 0002082C # asm("brb _sqrtf_5_lp1");; /* loop on the error */
875: 846 0002082C 11 e4 brb _sqrtf_5_lp1
876: 847 0002082E L320:
877: 848 0002082E # /*
878: 849 0002082E # * end error loop - test the results
879: 850 0002082E # */
880: 851 0002082E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
881: 852 0002082E 1d effffff8c8 effffff8c3 cmpl _sgl_st_acc,_sgl_expected
882: 853 00020839 21 03 13 00cf jeql L321
883: 854 0002083E # errcnt++; /* bump the error count */
884: 855 0002083E 6d effffff8b8 incl _errcnt
885: 856 00020844 # if( prt_error ) {
886: 857 00020844 5d effffff8b2 tstl _prt_error
887: 858 0002084A 21 03 13 009b jeql L322
888: 859 0002084F # writes(" \n"); /* start a new print line */
889: 860 0002084F .data 1
890: 861 00000c31 * L323:
891: 862 00000c31 * 200A00 .ascii " \12\0"
892: 863 00000c34 * .text
893: 864 0002084F dd 8f00000c31 pushl $L323
894: 865 00020855 fe 08 effffff8a0 callf $8,_writes
895: 866 0002085C # writes("cycle: ");
896: 867 0002085C .data 1
897: 868 00000c34 * L324:
898: 869 00000c34 * 6379636C653A2000 .ascii "cycle: \0"
899: 870 00000c3c * .text
900: 871 0002085C dd 8f00000c34 pushl $L324
901: 872 00020862 fe 08 effffff893 callf $8,_writes
902: 873 00020869 # writed( cycle );
903: 874 00020869 dd effffff88d pushl _cycle
904: 875 0002086F fe 08 effffff886 callf $8,_writed
905: 876 00020876 # writes(" SQRTF test ");
906: 877 00020876 .data 1
907: 878 00000c3c * L325:
908: 879 00000c3c * 2020535152544620746573742 .ascii " SQRTF test \0"
909: 000
910: 880 00000c4a * .text
911: 881 00020876 dd 8f00000c3c pushl $L325
912: 882 0002087C fe 08 effffff879 callf $8,_writes
913: 883 00020883 # writed( test_no );
914: 884 00020883 dd effffff873 pushl _test_no
915: 885 00020889 fe 08 effffff86c callf $8,_writed
916: 886 00020890 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n");
917: 887 00020890 .data 1
918: 888 00000c4a * L326:
919: 889 00000c4a * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0"
920: 8506970656420456E74727929
921: 202D204241442046494E414C2
922: 04143430A00
923: 890 00000c75 * .text
924: 891 00020890 dd 8f00000c4a pushl $L326
925: 892 00020896 fe 08 effffff85f callf $8,_writes
926: 893 0002089D # print_sqrtf_data();
927: 894 0002089D fe 04 ef000001d2 callf $4,_print_sqrtf_data
928: 895 000208A4 # writes(", data index = ");
929: 896 000208A4 .data 1
930: 897 00000c75 * L327:
931: 898 00000c75 * 2C20206461746120696E64657 .ascii ", data index = \0"
932: 8203D2000
933: 899 00000c86 * .text
934: 900 000208A4 dd 8f00000c75 pushl $L327
935: 901 000208AA fe 08 effffff84b callf $8,_writes
936: 902 000208B1 # writed( index );
937: 903 000208B1 dd effffff845 pushl _index
938: 904 000208B7 fe 08 effffff83e callf $8,_writed
939: 905 000208BE # writec('\n');
940: 906 000208BE dd 0a pushl $10
941: 907 000208C0 fe 08 effffff835 callf $8,_writec
942: 908 000208C7 # writes(" Acc expected = ");
943: 909 000208C7 .data 1
944: 910 00000c86 * L328:
945: 911 00000c86 * 2020202020202020202020202 .ascii " Acc expected = \0"
946: 0202020202020202020416363
947: 206578706563746564203D200
948: 0
949: 912 00000cac * .text
950: 913 000208C7 dd 8f00000c86 pushl $L328
951: 914 000208CD fe 08 effffff828 callf $8,_writes
952: 915 000208D4 # write32h( sgl_expected );
953: 916 000208D4 dd effffff822 pushl _sgl_expected
954: 917 000208DA fe 08 effffff81b callf $8,_write32h
955: 918 000208E1 # writec('\n');
956: 919 000208E1 dd 0a pushl $10
957: 920 000208E3 fe 08 effffff812 callf $8,_writec
958: 921 000208EA # }
959: 922 000208EA # if( halt_flg )
960: 923 000208EA L322:
961: 924 000208EA 5d effffff80c tstl _halt_flg
962: 925 000208F0 31 09 jeql L329
963: 926 000208F2 # sqrtf_er_halt( BAD_ACC_HLT ); /* halt on the error */
964: 927 000208F2 dd 01 pushl $1
965: 928 000208F4 fe 08 ef000001b7 callf $8,_sqrtf_er_halt
966: 929 000208FB # if( loop_on_err ) {
967: 930 000208FB L329:
968: 931 000208FB 5d effffff7fb tstl _loop_on_err
969: 932 00020901 31 0a jeql L330
970: 933 00020903 # force_loop = TRUE; /* set the force loop flag */
971: 934 00020903 0d 01 effffff7f2 movl $1,_force_loop
972: 935 0002090A # asm("brw _sqrtf_5_lp1");; /* and loop on the error */
973: 936 0002090A 13 ff05 brw _sqrtf_5_lp1
974: 937 0002090D # } /* end of loop on error */
975: 938 0002090D # } /* end of compare error */
976: 939 0002090D L330:
977: 940 0002090D # } /* end of WHILE loop */
978: 941 0002090D L321:
979: 942 0002090D L317:
980: 943 0002090D 6d effffff7e9 incl _index
981: 944 00020913 13 fec0 jbr L319
982: 945 00020916 L318:
983: 946 00020916 # } /* end of subtest 5 */
984: 947 00020916 40 ret#2
985: 948 00020917 .set L313,0x0
986: 949 00020917 L315:
987: 950 00020917 13 fea9 jbr L316
988: 951 0002091A .data
989: 952 00000a60 * .text
990: 953 0002091A .align 1
991: 954 0002091A .globl _sqrtf_6
992: 955 0002091A _sqrtf_6:
993: 956 0002091A 0000 .word L331
994: 957 0002091C #
995: 958 0002091C #
996: 959 0002091C #
997: 960 0002091C # /************************************************************************
998: 961 0002091C # *
999: 962 0002091C # * SUBTEST 6 - pipelined exit test
1000: 963 0002091C # *
1001: 964 0002091C # ************************************************************************/
1002: 965 0002091C # sqrtf_6()
1003: 966 0002091C # {
1004: 967 0002091C 13 0154 jbr L333
1005: 968 0002091F L334:
1006: 969 0002091F # force_loop = FALSE;
1007: 970 0002091F 4d effffff7d7 clrl _force_loop
1008: 971 00020925 # subtest = 8;
1009: 972 00020925 0d 08 effffff7d0 movl $8,_subtest
1010: 973 0002092C # for( index = 0; index < max_sqrtf_1_index; index++ ) {
1011: 974 0002092C 4d effffff7ca clrl _index
1012: 975 00020932 L337:
1013: 976 00020932 1d effffff7c4 effffff7bf cmpl _index,_max_sqrtf_1_index
1014: 977 0002093D 91 03 13 0130 jgeq L336
1015: 978 00020942 # sgl_ld_acc = sqrtf_1_data[index].ld; /* get operand 1 */
1016: 979 00020942 0d effffff7b4 50 movl _index,r0
1017: 980 00020949 48 03 50 50 shll $3,r0,r0
1018: 981 0002094D 0d e000000000 effffff7a4 movl _sqrtf_1_data(r0),_sgl_ld_acc
1019: 982 00020958 # sgl_expected = sqrtf_1_data[index].exp; /* get expected result */
1020: 983 00020958 0d effffff79e 50 movl _index,r0
1021: 984 0002095F 48 03 50 50 shll $3,r0,r0
1022: 985 00020963 0d e000000004 effffff78e movl _sqrtf_1_data+4(r0),_sgl_expected
1023: 986 0002096E # /*
1024: 987 0002096E # * If LOOP ON ERROR is set, this is the loop for this subtest.
1025: 988 0002096E # * The force loop flag is set after the first error.
1026: 989 0002096E # */
1027: 990 0002096E # asm("_sqrtf_6_lp1:");
1028: 991 0002096E _sqrtf_6_lp1:
1029: 992 0002096E # asm("movl $0,r0"); /* clear r0 */
1030: 993 0002096E 0d 00 50 movl $0,r0
1031: 994 00020971 # asm("ldf _sgl_ld_acc"); /* load the Acc. */
1032: 995 00020971 06 effffff785 ldf _sgl_ld_acc
1033: 996 00020977 # asm("sqrtf"); /* get the sqrt */
1034: 997 00020977 45 sqrtf
1035: 998 00020978 # asm("addf r0"); /* add a zero to the acc */
1036: 999 00020978 c6 50 addf r0
1037: 1000 0002097A # asm("stf _sgl_st_acc"); /* store the result */
1038: 1001 0002097A 26 effffff77c stf _sgl_st_acc
1039: 1002 00020980 # if( force_loop )
1040: 1003 00020980 5d effffff776 tstl _force_loop
1041: 1004 00020986 31 02 jeql L338
1042: 1005 00020988 # asm("brb _sqrtf_6_lp1");; /* loop on the error */
1043: 1006 00020988 11 e4 brb _sqrtf_6_lp1
1044: 1007 0002098A L338:
1045: 1008 0002098A # /*
1046: 1009 0002098A # * end error loop - test the results
1047: 1010 0002098A # */
1048: 1011 0002098A # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1049: 1012 0002098A 1d effffff76c effffff767 cmpl _sgl_st_acc,_sgl_expected
1050: 1013 00020995 21 03 13 00cf jeql L339
1051: 1014 0002099A # errcnt++; /* bump the error count */
1052: 1015 0002099A 6d effffff75c incl _errcnt
1053: 1016 000209A0 # if( prt_error ) {
1054: 1017 000209A0 5d effffff756 tstl _prt_error
1055: 1018 000209A6 21 03 13 009b jeql L340
1056: 1019 000209AB # writes(" \n"); /* start a new print line */
1057: 1020 000209AB .data 1
1058: 1021 00000cac * L341:
1059: 1022 00000cac * 200A00 .ascii " \12\0"
1060: 1023 00000caf * .text
1061: 1024 000209AB dd 8f00000cac pushl $L341
1062: 1025 000209B1 fe 08 effffff744 callf $8,_writes
1063: 1026 000209B8 # writes("cycle: ");
1064: 1027 000209B8 .data 1
1065: 1028 00000caf * L342:
1066: 1029 00000caf * 6379636C653A2000 .ascii "cycle: \0"
1067: 1030 00000cb7 * .text
1068: 1031 000209B8 dd 8f00000caf pushl $L342
1069: 1032 000209BE fe 08 effffff737 callf $8,_writes
1070: 1033 000209C5 # writed( cycle );
1071: 1034 000209C5 dd effffff731 pushl _cycle
1072: 1035 000209CB fe 08 effffff72a callf $8,_writed
1073: 1036 000209D2 # writes(" SQRTF test ");
1074: 1037 000209D2 .data 1
1075: 1038 00000cb7 * L343:
1076: 1039 00000cb7 * 2020535152544620746573742 .ascii " SQRTF test \0"
1077: 000
1078: 1040 00000cc5 * .text
1079: 1041 000209D2 dd 8f00000cb7 pushl $L343
1080: 1042 000209D8 fe 08 effffff71d callf $8,_writes
1081: 1043 000209DF # writed( test_no );
1082: 1044 000209DF dd effffff717 pushl _test_no
1083: 1045 000209E5 fe 08 effffff710 callf $8,_writed
1084: 1046 000209EC # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n");
1085: 1047 000209EC .data 1
1086: 1048 00000cc5 * L344:
1087: 1049 00000cc5 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0"
1088: 8506970656420457869742920
1089: 2D204241442046494E414C204
1090: 143430A00
1091: 1050 00000cef * .text
1092: 1051 000209EC dd 8f00000cc5 pushl $L344
1093: 1052 000209F2 fe 08 effffff703 callf $8,_writes
1094: 1053 000209F9 # print_sqrtf_data();
1095: 1054 000209F9 fe 04 ef00000076 callf $4,_print_sqrtf_data
1096: 1055 00020A00 # writes(", data index = ");
1097: 1056 00020A00 .data 1
1098: 1057 00000cef * L345:
1099: 1058 00000cef * 2C20206461746120696E64657 .ascii ", data index = \0"
1100: 8203D2000
1101: 1059 00000d00 * .text
1102: 1060 00020A00 dd 8f00000cef pushl $L345
1103: 1061 00020A06 fe 08 effffff6ef callf $8,_writes
1104: 1062 00020A0D # writed( index );
1105: 1063 00020A0D dd effffff6e9 pushl _index
1106: 1064 00020A13 fe 08 effffff6e2 callf $8,_writed
1107: 1065 00020A1A # writec('\n');
1108: 1066 00020A1A dd 0a pushl $10
1109: 1067 00020A1C fe 08 effffff6d9 callf $8,_writec
1110: 1068 00020A23 # writes(" Acc expected = ");
1111: 1069 00020A23 .data 1
1112: 1070 00000d00 * L346:
1113: 1071 00000d00 * 2020202020202020202020202 .ascii " Acc expected = \0"
1114: 0202020202020202020416363
1115: 206578706563746564203D200
1116: 0
1117: 1072 00000d26 * .text
1118: 1073 00020A23 dd 8f00000d00 pushl $L346
1119: 1074 00020A29 fe 08 effffff6cc callf $8,_writes
1120: 1075 00020A30 # write32h( sgl_expected );
1121: 1076 00020A30 dd effffff6c6 pushl _sgl_expected
1122: 1077 00020A36 fe 08 effffff6bf callf $8,_write32h
1123: 1078 00020A3D # writec('\n');
1124: 1079 00020A3D dd 0a pushl $10
1125: 1080 00020A3F fe 08 effffff6b6 callf $8,_writec
1126: 1081 00020A46 # }
1127: 1082 00020A46 # if( halt_flg )
1128: 1083 00020A46 L340:
1129: 1084 00020A46 5d effffff6b0 tstl _halt_flg
1130: 1085 00020A4C 31 09 jeql L347
1131: 1086 00020A4E # sqrtf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1132: 1087 00020A4E dd 01 pushl $1
1133: 1088 00020A50 fe 08 ef0000005b callf $8,_sqrtf_er_halt
1134: 1089 00020A57 # if( loop_on_err ) {
1135: 1090 00020A57 L347:
1136: 1091 00020A57 5d effffff69f tstl _loop_on_err
1137: 1092 00020A5D 31 0a jeql L348
1138: 1093 00020A5F # force_loop = TRUE; /* set the force loop flag */
1139: 1094 00020A5F 0d 01 effffff696 movl $1,_force_loop
1140: 1095 00020A66 # asm("brw _sqrtf_6_lp1");; /* and loop on the error */
1141: 1096 00020A66 13 ff05 brw _sqrtf_6_lp1
1142: 1097 00020A69 # } /* end of loop on error */
1143: 1098 00020A69 # } /* end of compare error */
1144: 1099 00020A69 L348:
1145: 1100 00020A69 # } /* end of WHILE loop */
1146: 1101 00020A69 L339:
1147: 1102 00020A69 L335:
1148: 1103 00020A69 6d effffff68d incl _index
1149: 1104 00020A6F 13 fec0 jbr L337
1150: 1105 00020A72 L336:
1151: 1106 00020A72 # } /* end of subtest 6 */
1152: 1107 00020A72 40 ret#2
1153: 1108 00020A73 .set L331,0x0
1154: 1109 00020A73 L333:
1155: 1110 00020A73 13 fea9 jbr L334
1156: 1111 00020A76 .data
1157: 1112 00000a60 * .text
1158: 1113 00020A76 .align 1
1159: 1114 00020A76 .globl _print_sqrtf_data
1160: 1115 00020A76 _print_sqrtf_data:
1161: 1116 00020A76 0000 .word L349
1162: 1117 00020A78 #
1163: 1118 00020A78 #
1164: 1119 00020A78 #
1165: 1120 00020A78 # /**************************************************************************
1166: 1121 00020A78 # *
1167: 1122 00020A78 # * PRINT THE DATA AND STORE RESULTS
1168: 1123 00020A78 # *
1169: 1124 00020A78 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1170: 1125 00020A78 # * Acc expected = xxxxxxxx
1171: 1126 00020A78 # **************************************************************************/
1172: 1127 00020A78 # print_sqrtf_data()
1173: 1128 00020A78 # {
1174: 1129 00020A78 11 35 jbr L351
1175: 1130 00020A7A L352:
1176: 1131 00020A7A # writes("initial Acc = ");
1177: 1132 00020A7A .data 1
1178: 1133 00000d26 * L353:
1179: 1134 00000d26 * 696E697469616C20416363203 .ascii "initial Acc = \0"
1180: D2000
1181: 1135 00000d35 * .text
1182: 1136 00020A7A dd 8f00000d26 pushl $L353
1183: 1137 00020A80 fe 08 effffff675 callf $8,_writes
1184: 1138 00020A87 # write32h( sgl_ld_acc );
1185: 1139 00020A87 dd effffff66f pushl _sgl_ld_acc
1186: 1140 00020A8D fe 08 effffff668 callf $8,_write32h
1187: 1141 00020A94 # writes(", final Acc = ");
1188: 1142 00020A94 .data 1
1189: 1143 00000d35 * L354:
1190: 1144 00000d35 * 2C202066696E616C204163632 .ascii ", final Acc = \0"
1191: 03D2000
1192: 1145 00000d45 * .text
1193: 1146 00020A94 dd 8f00000d35 pushl $L354
1194: 1147 00020A9A fe 08 effffff65b callf $8,_writes
1195: 1148 00020AA1 # write32h( sgl_st_acc );
1196: 1149 00020AA1 dd effffff655 pushl _sgl_st_acc
1197: 1150 00020AA7 fe 08 effffff64e callf $8,_write32h
1198: 1151 00020AAE # }
1199: 1152 00020AAE 40 ret#2
1200: 1153 00020AAF .set L349,0x0
1201: 1154 00020AAF L351:
1202: 1155 00020AAF 11 c9 jbr L352
1203: 1156 00020AB1 .data
1204: 1157 00000a60 * .text
1205: 1158 00020AB1 00 .align 1
1206: 1159 00020AB2 .globl _sqrtf_er_halt
1207: 1160 00020AB2 _sqrtf_er_halt:
1208: 1161 00020AB2 0000 .word L355
1209: 1162 00020AB4 #
1210: 1163 00020AB4 #
1211: 1164 00020AB4 #
1212: 1165 00020AB4 # /**************************************************************************
1213: 1166 00020AB4 # *
1214: 1167 00020AB4 # * HALT ON ERROR ROUTINE
1215: 1168 00020AB4 # *
1216: 1169 00020AB4 # **************************************************************************/
1217: 1170 00020AB4 # sqrtf_er_halt( halt_code )
1218: 1171 00020AB4 # int halt_code;
1219: 1172 00020AB4 # {
1220: 1173 00020AB4 13 00a0 jbr L357
1221: 1174 00020AB7 L358:
1222: 1175 00020AB7 # sgl_dummy1 = halt_code; /* get the error type */
1223: 1176 00020AB7 0d ad04 effffff63d movl 4(fp),_sgl_dummy1
1224: 1177 00020ABF # asm("movl _test_no,r0"); /* r0 = test number */
1225: 1178 00020ABF 0d effffff637 50 movl _test_no,r0
1226: 1179 00020AC6 # asm("movl _subtest,r1"); /* r1 = subtest number */
1227: 1180 00020AC6 0d effffff630 51 movl _subtest,r1
1228: 1181 00020ACD # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1229: 1182 00020ACD 0d effffff629 52 movl _sgl_dummy1,r2
1230: 1183 00020AD4 # asm("movl _cycle,r3"); /* r3 = cycle count */
1231: 1184 00020AD4 0d effffff622 53 movl _cycle,r3
1232: 1185 00020ADB # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1233: 1186 00020ADB 0d effffff61b 54 movl _sgl_ld_acc,r4
1234: 1187 00020AE2 # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */
1235: 1188 00020AE2 0d effffff614 55 movl _sgl_st_acc,r5
1236: 1189 00020AE9 # asm("movl _sgl_expected,r6"); /* r6 = data expected */
1237: 1190 00020AE9 0d effffff60d 56 movl _sgl_expected,r6
1238: 1191 00020AF0 # asm("movl _index,r7"); /* r7 = data index */
1239: 1192 00020AF0 0d effffff606 57 movl _index,r7
1240: 1193 00020AF7 # if( halt_code == BAD_REG_HLT ) {
1241: 1194 00020AF7 1d ad04 02 cmpl 4(fp),$2
1242: 1195 00020AFB 21 3d jneq L359
1243: 1196 00020AFD # sgl_dummy1 = load_regs[index2];
1244: 1197 00020AFD 0d effffff5f9 50 movl _index2,r0
1245: 1198 00020B04 0d 40effffff5f1 movl _load_regs[r0],_sgl_dummy1
1246: effffff5ec
1247: 1199 00020B10 # sgl_dummy2 = store_regs[index2];
1248: 1200 00020B10 0d effffff5e6 50 movl _index2,r0
1249: 1201 00020B17 0d 40effffff5de movl _store_regs[r0],_sgl_dummy2
1250: effffff5d9
1251: 1202 00020B23 # asm("movl _index2,r6"); /* r6 = bad register # */
1252: 1203 00020B23 0d effffff5d3 56 movl _index2,r6
1253: 1204 00020B2A # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */
1254: 1205 00020B2A 0d effffff5cc 57 movl _sgl_dummy2,r7
1255: 1206 00020B31 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */
1256: 1207 00020B31 0d effffff5c5 58 movl _sgl_dummy1,r8
1257: 1208 00020B38 # } else
1258: 1209 00020B38 11 1b jbr L360
1259: 1210 00020B3A L359:
1260: 1211 00020B3A # if( halt_code == BAD_PSL_HLT ) {
1261: 1212 00020B3A 1d ad04 03 cmpl 4(fp),$3
1262: 1213 00020B3E 21 15 jneq L361
1263: 1214 00020B40 # asm("movl _init_psl,r6"); /* r6 = initial PSL */
1264: 1215 00020B40 0d effffff5b6 56 movl _init_psl,r6
1265: 1216 00020B47 # asm("movl _psl_val,r7"); /* r7 = final PSL */
1266: 1217 00020B47 0d effffff5af 57 movl _psl_val,r7
1267: 1218 00020B4E # asm("movl _exp_psl,r8"); /* r8 = expected PSL */
1268: 1219 00020B4E 0d effffff5a8 58 movl _exp_psl,r8
1269: 1220 00020B55 # };
1270: 1221 00020B55 L361:
1271: 1222 00020B55 L360:
1272: 1223 00020B55 # asm("halt"); /* HALT ... */
1273: 1224 00020B55 00 halt
1274: 1225 00020B56 # }
1275: 1226 00020B56 40 ret#2
1276: 1227 00020B57 .set L355,0x0
1277: 1228 00020B57 L357:
1278: 1229 00020B57 13 ff5d jbr L358
1279: 1230 00020B5A .data
1280: 1230 00040C56 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.