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