3ba446a99a12372992071f99130541fac45505c4
[linux-3.10.git] / arch / m68k / fpsp040 / bindec.S
1 |
2 |       bindec.sa 3.4 1/3/91
3 |
4 |       bindec
5 |
6 |       Description:
7 |               Converts an input in extended precision format
8 |               to bcd format.
9 |
10 |       Input:
11 |               a0 points to the input extended precision value
12 |               value in memory; d0 contains the k-factor sign-extended
13 |               to 32-bits.  The input may be either normalized,
14 |               unnormalized, or denormalized.
15 |
16 |       Output: result in the FP_SCR1 space on the stack.
17 |
18 |       Saves and Modifies: D2-D7,A2,FP2
19 |
20 |       Algorithm:
21 |
22 |       A1.     Set RM and size ext;  Set SIGMA = sign of input.
23 |               The k-factor is saved for use in d7. Clear the
24 |               BINDEC_FLG for separating normalized/denormalized
25 |               input.  If input is unnormalized or denormalized,
26 |               normalize it.
27 |
28 |       A2.     Set X = abs(input).
29 |
30 |       A3.     Compute ILOG.
31 |               ILOG is the log base 10 of the input value.  It is
32 |               approximated by adding e + 0.f when the original
33 |               value is viewed as 2^^e * 1.f in extended precision.
34 |               This value is stored in d6.
35 |
36 |       A4.     Clr INEX bit.
37 |               The operation in A3 above may have set INEX2.
38 |
39 |       A5.     Set ICTR = 0;
40 |               ICTR is a flag used in A13.  It must be set before the
41 |               loop entry A6.
42 |
43 |       A6.     Calculate LEN.
44 |               LEN is the number of digits to be displayed.  The
45 |               k-factor can dictate either the total number of digits,
46 |               if it is a positive number, or the number of digits
47 |               after the decimal point which are to be included as
48 |               significant.  See the 68882 manual for examples.
49 |               If LEN is computed to be greater than 17, set OPERR in
50 |               USER_FPSR.  LEN is stored in d4.
51 |
52 |       A7.     Calculate SCALE.
53 |               SCALE is equal to 10^ISCALE, where ISCALE is the number
54 |               of decimal places needed to insure LEN integer digits
55 |               in the output before conversion to bcd. LAMBDA is the
56 |               sign of ISCALE, used in A9. Fp1 contains
57 |               10^^(abs(ISCALE)) using a rounding mode which is a
58 |               function of the original rounding mode and the signs
59 |               of ISCALE and X.  A table is given in the code.
60 |
61 |       A8.     Clr INEX; Force RZ.
62 |               The operation in A3 above may have set INEX2.
63 |               RZ mode is forced for the scaling operation to insure
64 |               only one rounding error.  The grs bits are collected in
65 |               the INEX flag for use in A10.
66 |
67 |       A9.     Scale X -> Y.
68 |               The mantissa is scaled to the desired number of
69 |               significant digits.  The excess digits are collected
70 |               in INEX2.
71 |
72 |       A10.    Or in INEX.
73 |               If INEX is set, round error occurred.  This is
74 |               compensated for by 'or-ing' in the INEX2 flag to
75 |               the lsb of Y.
76 |
77 |       A11.    Restore original FPCR; set size ext.
78 |               Perform FINT operation in the user's rounding mode.
79 |               Keep the size to extended.
80 |
81 |       A12.    Calculate YINT = FINT(Y) according to user's rounding
82 |               mode.  The FPSP routine sintd0 is used.  The output
83 |               is in fp0.
84 |
85 |       A13.    Check for LEN digits.
86 |               If the int operation results in more than LEN digits,
87 |               or less than LEN -1 digits, adjust ILOG and repeat from
88 |               A6.  This test occurs only on the first pass.  If the
89 |               result is exactly 10^LEN, decrement ILOG and divide
90 |               the mantissa by 10.
91 |
92 |       A14.    Convert the mantissa to bcd.
93 |               The binstr routine is used to convert the LEN digit
94 |               mantissa to bcd in memory.  The input to binstr is
95 |               to be a fraction; i.e. (mantissa)/10^LEN and adjusted
96 |               such that the decimal point is to the left of bit 63.
97 |               The bcd digits are stored in the correct position in
98 |               the final string area in memory.
99 |
100 |       A15.    Convert the exponent to bcd.
101 |               As in A14 above, the exp is converted to bcd and the
102 |               digits are stored in the final string.
103 |               Test the length of the final exponent string.  If the
104 |               length is 4, set operr.
105 |
106 |       A16.    Write sign bits to final string.
107 |
108 |       Implementation Notes:
109 |
110 |       The registers are used as follows:
111 |
112 |               d0: scratch; LEN input to binstr
113 |               d1: scratch
114 |               d2: upper 32-bits of mantissa for binstr
115 |               d3: scratch;lower 32-bits of mantissa for binstr
116 |               d4: LEN
117 |               d5: LAMBDA/ICTR
118 |               d6: ILOG
119 |               d7: k-factor
120 |               a0: ptr for original operand/final result
121 |               a1: scratch pointer
122 |               a2: pointer to FP_X; abs(original value) in ext
123 |               fp0: scratch
124 |               fp1: scratch
125 |               fp2: scratch
126 |               F_SCR1:
127 |               F_SCR2:
128 |               L_SCR1:
129 |               L_SCR2:
130
131 |               Copyright (C) Motorola, Inc. 1990
132 |                       All Rights Reserved
133 |
134 |       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
135 |       The copyright notice above does not evidence any
136 |       actual or intended publication of such source code.
137
138 |BINDEC    idnt    2,1 | Motorola 040 Floating Point Software Package
139
140 #include "fpsp.h"
141
142         |section        8
143
144 | Constants in extended precision
145 LOG2:   .long   0x3FFD0000,0x9A209A84,0xFBCFF798,0x00000000
146 LOG2UP1:        .long   0x3FFD0000,0x9A209A84,0xFBCFF799,0x00000000
147
148 | Constants in single precision
149 FONE:   .long   0x3F800000,0x00000000,0x00000000,0x00000000
150 FTWO:   .long   0x40000000,0x00000000,0x00000000,0x00000000
151 FTEN:   .long   0x41200000,0x00000000,0x00000000,0x00000000
152 F4933:  .long   0x459A2800,0x00000000,0x00000000,0x00000000
153
154 RBDTBL: .byte   0,0,0,0
155         .byte   3,3,2,2
156         .byte   3,2,2,3
157         .byte   2,3,3,2
158
159         |xref   binstr
160         |xref   sintdo
161         |xref   ptenrn,ptenrm,ptenrp
162
163         .global bindec
164         .global sc_mul
165 bindec:
166         moveml  %d2-%d7/%a2,-(%a7)
167         fmovemx %fp0-%fp2,-(%a7)
168
169 | A1. Set RM and size ext. Set SIGMA = sign input;
170 |     The k-factor is saved for use in d7.  Clear BINDEC_FLG for
171 |     separating  normalized/denormalized input.  If the input
172 |     is a denormalized number, set the BINDEC_FLG memory word
173 |     to signal denorm.  If the input is unnormalized, normalize
174 |     the input and test for denormalized result.
175 |
176         fmovel  #rm_mode,%FPCR  |set RM and ext
177         movel   (%a0),L_SCR2(%a6)       |save exponent for sign check
178         movel   %d0,%d7         |move k-factor to d7
179         clrb    BINDEC_FLG(%a6) |clr norm/denorm flag
180         movew   STAG(%a6),%d0   |get stag
181         andiw   #0xe000,%d0     |isolate stag bits
182         beq     A2_str          |if zero, input is norm
183 |
184 | Normalize the denorm
185 |
186 un_de_norm:
187         movew   (%a0),%d0
188         andiw   #0x7fff,%d0     |strip sign of normalized exp
189         movel   4(%a0),%d1
190         movel   8(%a0),%d2
191 norm_loop:
192         subw    #1,%d0
193         lsll    #1,%d2
194         roxll   #1,%d1
195         tstl    %d1
196         bges    norm_loop
197 |
198 | Test if the normalized input is denormalized
199 |
200         tstw    %d0
201         bgts    pos_exp         |if greater than zero, it is a norm
202         st      BINDEC_FLG(%a6) |set flag for denorm
203 pos_exp:
204         andiw   #0x7fff,%d0     |strip sign of normalized exp
205         movew   %d0,(%a0)
206         movel   %d1,4(%a0)
207         movel   %d2,8(%a0)
208
209 | A2. Set X = abs(input).
210 |
211 A2_str:
212         movel   (%a0),FP_SCR2(%a6) | move input to work space
213         movel   4(%a0),FP_SCR2+4(%a6) | move input to work space
214         movel   8(%a0),FP_SCR2+8(%a6) | move input to work space
215         andil   #0x7fffffff,FP_SCR2(%a6) |create abs(X)
216
217 | A3. Compute ILOG.
218 |     ILOG is the log base 10 of the input value.  It is approx-
219 |     imated by adding e + 0.f when the original value is viewed
220 |     as 2^^e * 1.f in extended precision.  This value is stored
221 |     in d6.
222 |
223 | Register usage:
224 |       Input/Output
225 |       d0: k-factor/exponent
226 |       d2: x/x
227 |       d3: x/x
228 |       d4: x/x
229 |       d5: x/x
230 |       d6: x/ILOG
231 |       d7: k-factor/Unchanged
232 |       a0: ptr for original operand/final result
233 |       a1: x/x
234 |       a2: x/x
235 |       fp0: x/float(ILOG)
236 |       fp1: x/x
237 |       fp2: x/x
238 |       F_SCR1:x/x
239 |       F_SCR2:Abs(X)/Abs(X) with $3fff exponent
240 |       L_SCR1:x/x
241 |       L_SCR2:first word of X packed/Unchanged
242
243         tstb    BINDEC_FLG(%a6) |check for denorm
244         beqs    A3_cont         |if clr, continue with norm
245         movel   #-4933,%d6      |force ILOG = -4933
246         bras    A4_str
247 A3_cont:
248         movew   FP_SCR2(%a6),%d0        |move exp to d0
249         movew   #0x3fff,FP_SCR2(%a6) |replace exponent with 0x3fff
250         fmovex  FP_SCR2(%a6),%fp0       |now fp0 has 1.f
251         subw    #0x3fff,%d0     |strip off bias
252         faddw   %d0,%fp0                |add in exp
253         fsubs   FONE,%fp0       |subtract off 1.0
254         fbge    pos_res         |if pos, branch
255         fmulx   LOG2UP1,%fp0    |if neg, mul by LOG2UP1
256         fmovel  %fp0,%d6                |put ILOG in d6 as a lword
257         bras    A4_str          |go move out ILOG
258 pos_res:
259         fmulx   LOG2,%fp0       |if pos, mul by LOG2
260         fmovel  %fp0,%d6                |put ILOG in d6 as a lword
261
262
263 | A4. Clr INEX bit.
264 |     The operation in A3 above may have set INEX2.
265
266 A4_str:
267         fmovel  #0,%FPSR                |zero all of fpsr - nothing needed
268
269
270 | A5. Set ICTR = 0;
271 |     ICTR is a flag used in A13.  It must be set before the
272 |     loop entry A6. The lower word of d5 is used for ICTR.
273
274         clrw    %d5             |clear ICTR
275
276
277 | A6. Calculate LEN.
278 |     LEN is the number of digits to be displayed.  The k-factor
279 |     can dictate either the total number of digits, if it is
280 |     a positive number, or the number of digits after the
281 |     original decimal point which are to be included as
282 |     significant.  See the 68882 manual for examples.
283 |     If LEN is computed to be greater than 17, set OPERR in
284 |     USER_FPSR.  LEN is stored in d4.
285 |
286 | Register usage:
287 |       Input/Output
288 |       d0: exponent/Unchanged
289 |       d2: x/x/scratch
290 |       d3: x/x
291 |       d4: exc picture/LEN
292 |       d5: ICTR/Unchanged
293 |       d6: ILOG/Unchanged
294 |       d7: k-factor/Unchanged
295 |       a0: ptr for original operand/final result
296 |       a1: x/x
297 |       a2: x/x
298 |       fp0: float(ILOG)/Unchanged
299 |       fp1: x/x
300 |       fp2: x/x
301 |       F_SCR1:x/x
302 |       F_SCR2:Abs(X) with $3fff exponent/Unchanged
303 |       L_SCR1:x/x
304 |       L_SCR2:first word of X packed/Unchanged
305
306 A6_str:
307         tstl    %d7             |branch on sign of k
308         bles    k_neg           |if k <= 0, LEN = ILOG + 1 - k
309         movel   %d7,%d4         |if k > 0, LEN = k
310         bras    len_ck          |skip to LEN check
311 k_neg:
312         movel   %d6,%d4         |first load ILOG to d4
313         subl    %d7,%d4         |subtract off k
314         addql   #1,%d4          |add in the 1
315 len_ck:
316         tstl    %d4             |LEN check: branch on sign of LEN
317         bles    LEN_ng          |if neg, set LEN = 1
318         cmpl    #17,%d4         |test if LEN > 17
319         bles    A7_str          |if not, forget it
320         movel   #17,%d4         |set max LEN = 17
321         tstl    %d7             |if negative, never set OPERR
322         bles    A7_str          |if positive, continue
323         orl     #opaop_mask,USER_FPSR(%a6) |set OPERR & AIOP in USER_FPSR
324         bras    A7_str          |finished here
325 LEN_ng:
326         moveql  #1,%d4          |min LEN is 1
327
328
329 | A7. Calculate SCALE.
330 |     SCALE is equal to 10^ISCALE, where ISCALE is the number
331 |     of decimal places needed to insure LEN integer digits
332 |     in the output before conversion to bcd. LAMBDA is the sign
333 |     of ISCALE, used in A9.  Fp1 contains 10^^(abs(ISCALE)) using
334 |     the rounding mode as given in the following table (see
335 |     Coonen, p. 7.23 as ref.; however, the SCALE variable is
336 |     of opposite sign in bindec.sa from Coonen).
337 |
338 |       Initial                                 USE
339 |       FPCR[6:5]       LAMBDA  SIGN(X)         FPCR[6:5]
340 |       ----------------------------------------------
341 |        RN     00         0       0            00/0    RN
342 |        RN     00         0       1            00/0    RN
343 |        RN     00         1       0            00/0    RN
344 |        RN     00         1       1            00/0    RN
345 |        RZ     01         0       0            11/3    RP
346 |        RZ     01         0       1            11/3    RP
347 |        RZ     01         1       0            10/2    RM
348 |        RZ     01         1       1            10/2    RM
349 |        RM     10         0       0            11/3    RP
350 |        RM     10         0       1            10/2    RM
351 |        RM     10         1       0            10/2    RM
352 |        RM     10         1       1            11/3    RP
353 |        RP     11         0       0            10/2    RM
354 |        RP     11         0       1            11/3    RP
355 |        RP     11         1       0            11/3    RP
356 |        RP     11         1       1            10/2    RM
357 |
358 | Register usage:
359 |       Input/Output
360 |       d0: exponent/scratch - final is 0
361 |       d2: x/0 or 24 for A9
362 |       d3: x/scratch - offset ptr into PTENRM array
363 |       d4: LEN/Unchanged
364 |       d5: 0/ICTR:LAMBDA
365 |       d6: ILOG/ILOG or k if ((k<=0)&(ILOG<k))
366 |       d7: k-factor/Unchanged
367 |       a0: ptr for original operand/final result
368 |       a1: x/ptr to PTENRM array
369 |       a2: x/x
370 |       fp0: float(ILOG)/Unchanged
371 |       fp1: x/10^ISCALE
372 |       fp2: x/x
373 |       F_SCR1:x/x
374 |       F_SCR2:Abs(X) with $3fff exponent/Unchanged
375 |       L_SCR1:x/x
376 |       L_SCR2:first word of X packed/Unchanged
377
378 A7_str:
379         tstl    %d7             |test sign of k
380         bgts    k_pos           |if pos and > 0, skip this
381         cmpl    %d6,%d7         |test k - ILOG
382         blts    k_pos           |if ILOG >= k, skip this
383         movel   %d7,%d6         |if ((k<0) & (ILOG < k)) ILOG = k
384 k_pos:
385         movel   %d6,%d0         |calc ILOG + 1 - LEN in d0
386         addql   #1,%d0          |add the 1
387         subl    %d4,%d0         |sub off LEN
388         swap    %d5             |use upper word of d5 for LAMBDA
389         clrw    %d5             |set it zero initially
390         clrw    %d2             |set up d2 for very small case
391         tstl    %d0             |test sign of ISCALE
392         bges    iscale          |if pos, skip next inst
393         addqw   #1,%d5          |if neg, set LAMBDA true
394         cmpl    #0xffffecd4,%d0 |test iscale <= -4908
395         bgts    no_inf          |if false, skip rest
396         addil   #24,%d0         |add in 24 to iscale
397         movel   #24,%d2         |put 24 in d2 for A9
398 no_inf:
399         negl    %d0             |and take abs of ISCALE
400 iscale:
401         fmoves  FONE,%fp1       |init fp1 to 1
402         bfextu  USER_FPCR(%a6){#26:#2},%d1 |get initial rmode bits
403         lslw    #1,%d1          |put them in bits 2:1
404         addw    %d5,%d1         |add in LAMBDA
405         lslw    #1,%d1          |put them in bits 3:1
406         tstl    L_SCR2(%a6)     |test sign of original x
407         bges    x_pos           |if pos, don't set bit 0
408         addql   #1,%d1          |if neg, set bit 0
409 x_pos:
410         leal    RBDTBL,%a2      |load rbdtbl base
411         moveb   (%a2,%d1),%d3   |load d3 with new rmode
412         lsll    #4,%d3          |put bits in proper position
413         fmovel  %d3,%fpcr               |load bits into fpu
414         lsrl    #4,%d3          |put bits in proper position
415         tstb    %d3             |decode new rmode for pten table
416         bnes    not_rn          |if zero, it is RN
417         leal    PTENRN,%a1      |load a1 with RN table base
418         bras    rmode           |exit decode
419 not_rn:
420         lsrb    #1,%d3          |get lsb in carry
421         bccs    not_rp          |if carry clear, it is RM
422         leal    PTENRP,%a1      |load a1 with RP table base
423         bras    rmode           |exit decode
424 not_rp:
425         leal    PTENRM,%a1      |load a1 with RM table base
426 rmode:
427         clrl    %d3             |clr table index
428 e_loop:
429         lsrl    #1,%d0          |shift next bit into carry
430         bccs    e_next          |if zero, skip the mul
431         fmulx   (%a1,%d3),%fp1  |mul by 10**(d3_bit_no)
432 e_next:
433         addl    #12,%d3         |inc d3 to next pwrten table entry
434         tstl    %d0             |test if ISCALE is zero
435         bnes    e_loop          |if not, loop
436
437
438 | A8. Clr INEX; Force RZ.
439 |     The operation in A3 above may have set INEX2.
440 |     RZ mode is forced for the scaling operation to insure
441 |     only one rounding error.  The grs bits are collected in
442 |     the INEX flag for use in A10.
443 |
444 | Register usage:
445 |       Input/Output
446
447         fmovel  #0,%FPSR                |clr INEX
448         fmovel  #rz_mode,%FPCR  |set RZ rounding mode
449
450
451 | A9. Scale X -> Y.
452 |     The mantissa is scaled to the desired number of significant
453 |     digits.  The excess digits are collected in INEX2. If mul,
454 |     Check d2 for excess 10 exponential value.  If not zero,
455 |     the iscale value would have caused the pwrten calculation
456 |     to overflow.  Only a negative iscale can cause this, so
457 |     multiply by 10^(d2), which is now only allowed to be 24,
458 |     with a multiply by 10^8 and 10^16, which is exact since
459 |     10^24 is exact.  If the input was denormalized, we must
460 |     create a busy stack frame with the mul command and the
461 |     two operands, and allow the fpu to complete the multiply.
462 |
463 | Register usage:
464 |       Input/Output
465 |       d0: FPCR with RZ mode/Unchanged
466 |       d2: 0 or 24/unchanged
467 |       d3: x/x
468 |       d4: LEN/Unchanged
469 |       d5: ICTR:LAMBDA
470 |       d6: ILOG/Unchanged
471 |       d7: k-factor/Unchanged
472 |       a0: ptr for original operand/final result
473 |       a1: ptr to PTENRM array/Unchanged
474 |       a2: x/x
475 |       fp0: float(ILOG)/X adjusted for SCALE (Y)
476 |       fp1: 10^ISCALE/Unchanged
477 |       fp2: x/x
478 |       F_SCR1:x/x
479 |       F_SCR2:Abs(X) with $3fff exponent/Unchanged
480 |       L_SCR1:x/x
481 |       L_SCR2:first word of X packed/Unchanged
482
483 A9_str:
484         fmovex  (%a0),%fp0      |load X from memory
485         fabsx   %fp0            |use abs(X)
486         tstw    %d5             |LAMBDA is in lower word of d5
487         bne     sc_mul          |if neg (LAMBDA = 1), scale by mul
488         fdivx   %fp1,%fp0               |calculate X / SCALE -> Y to fp0
489         bras    A10_st          |branch to A10
490
491 sc_mul:
492         tstb    BINDEC_FLG(%a6) |check for denorm
493         beqs    A9_norm         |if norm, continue with mul
494         fmovemx %fp1-%fp1,-(%a7)        |load ETEMP with 10^ISCALE
495         movel   8(%a0),-(%a7)   |load FPTEMP with input arg
496         movel   4(%a0),-(%a7)
497         movel   (%a0),-(%a7)
498         movel   #18,%d3         |load count for busy stack
499 A9_loop:
500         clrl    -(%a7)          |clear lword on stack
501         dbf     %d3,A9_loop
502         moveb   VER_TMP(%a6),(%a7) |write current version number
503         moveb   #BUSY_SIZE-4,1(%a7) |write current busy size
504         moveb   #0x10,0x44(%a7) |set fcefpte[15] bit
505         movew   #0x0023,0x40(%a7)       |load cmdreg1b with mul command
506         moveb   #0xfe,0x8(%a7)  |load all 1s to cu savepc
507         frestore (%a7)+         |restore frame to fpu for completion
508         fmulx   36(%a1),%fp0    |multiply fp0 by 10^8
509         fmulx   48(%a1),%fp0    |multiply fp0 by 10^16
510         bras    A10_st
511 A9_norm:
512         tstw    %d2             |test for small exp case
513         beqs    A9_con          |if zero, continue as normal
514         fmulx   36(%a1),%fp0    |multiply fp0 by 10^8
515         fmulx   48(%a1),%fp0    |multiply fp0 by 10^16
516 A9_con:
517         fmulx   %fp1,%fp0               |calculate X * SCALE -> Y to fp0
518
519
520 | A10. Or in INEX.
521 |      If INEX is set, round error occurred.  This is compensated
522 |      for by 'or-ing' in the INEX2 flag to the lsb of Y.
523 |
524 | Register usage:
525 |       Input/Output
526 |       d0: FPCR with RZ mode/FPSR with INEX2 isolated
527 |       d2: x/x
528 |       d3: x/x
529 |       d4: LEN/Unchanged
530 |       d5: ICTR:LAMBDA
531 |       d6: ILOG/Unchanged
532 |       d7: k-factor/Unchanged
533 |       a0: ptr for original operand/final result
534 |       a1: ptr to PTENxx array/Unchanged
535 |       a2: x/ptr to FP_SCR2(a6)
536 |       fp0: Y/Y with lsb adjusted
537 |       fp1: 10^ISCALE/Unchanged
538 |       fp2: x/x
539
540 A10_st:
541         fmovel  %FPSR,%d0               |get FPSR
542         fmovex  %fp0,FP_SCR2(%a6)       |move Y to memory
543         leal    FP_SCR2(%a6),%a2        |load a2 with ptr to FP_SCR2
544         btstl   #9,%d0          |check if INEX2 set
545         beqs    A11_st          |if clear, skip rest
546         oril    #1,8(%a2)       |or in 1 to lsb of mantissa
547         fmovex  FP_SCR2(%a6),%fp0       |write adjusted Y back to fpu
548
549
550 | A11. Restore original FPCR; set size ext.
551 |      Perform FINT operation in the user's rounding mode.  Keep
552 |      the size to extended.  The sintdo entry point in the sint
553 |      routine expects the FPCR value to be in USER_FPCR for
554 |      mode and precision.  The original FPCR is saved in L_SCR1.
555
556 A11_st:
557         movel   USER_FPCR(%a6),L_SCR1(%a6) |save it for later
558         andil   #0x00000030,USER_FPCR(%a6) |set size to ext,
559 |                                       ;block exceptions
560
561
562 | A12. Calculate YINT = FINT(Y) according to user's rounding mode.
563 |      The FPSP routine sintd0 is used.  The output is in fp0.
564 |
565 | Register usage:
566 |       Input/Output
567 |       d0: FPSR with AINEX cleared/FPCR with size set to ext
568 |       d2: x/x/scratch
569 |       d3: x/x
570 |       d4: LEN/Unchanged
571 |       d5: ICTR:LAMBDA/Unchanged
572 |       d6: ILOG/Unchanged
573 |       d7: k-factor/Unchanged
574 |       a0: ptr for original operand/src ptr for sintdo
575 |       a1: ptr to PTENxx array/Unchanged
576 |       a2: ptr to FP_SCR2(a6)/Unchanged
577 |       a6: temp pointer to FP_SCR2(a6) - orig value saved and restored
578 |       fp0: Y/YINT
579 |       fp1: 10^ISCALE/Unchanged
580 |       fp2: x/x
581 |       F_SCR1:x/x
582 |       F_SCR2:Y adjusted for inex/Y with original exponent
583 |       L_SCR1:x/original USER_FPCR
584 |       L_SCR2:first word of X packed/Unchanged
585
586 A12_st:
587         moveml  %d0-%d1/%a0-%a1,-(%a7)  |save regs used by sintd0
588         movel   L_SCR1(%a6),-(%a7)
589         movel   L_SCR2(%a6),-(%a7)
590         leal    FP_SCR2(%a6),%a0                |a0 is ptr to F_SCR2(a6)
591         fmovex  %fp0,(%a0)              |move Y to memory at FP_SCR2(a6)
592         tstl    L_SCR2(%a6)             |test sign of original operand
593         bges    do_fint                 |if pos, use Y
594         orl     #0x80000000,(%a0)               |if neg, use -Y
595 do_fint:
596         movel   USER_FPSR(%a6),-(%a7)
597         bsr     sintdo                  |sint routine returns int in fp0
598         moveb   (%a7),USER_FPSR(%a6)
599         addl    #4,%a7
600         movel   (%a7)+,L_SCR2(%a6)
601         movel   (%a7)+,L_SCR1(%a6)
602         moveml  (%a7)+,%d0-%d1/%a0-%a1  |restore regs used by sint
603         movel   L_SCR2(%a6),FP_SCR2(%a6)        |restore original exponent
604         movel   L_SCR1(%a6),USER_FPCR(%a6) |restore user's FPCR
605
606
607 | A13. Check for LEN digits.
608 |      If the int operation results in more than LEN digits,
609 |      or less than LEN -1 digits, adjust ILOG and repeat from
610 |      A6.  This test occurs only on the first pass.  If the
611 |      result is exactly 10^LEN, decrement ILOG and divide
612 |      the mantissa by 10.  The calculation of 10^LEN cannot
613 |      be inexact, since all powers of ten upto 10^27 are exact
614 |      in extended precision, so the use of a previous power-of-ten
615 |      table will introduce no error.
616 |
617 |
618 | Register usage:
619 |       Input/Output
620 |       d0: FPCR with size set to ext/scratch final = 0
621 |       d2: x/x
622 |       d3: x/scratch final = x
623 |       d4: LEN/LEN adjusted
624 |       d5: ICTR:LAMBDA/LAMBDA:ICTR
625 |       d6: ILOG/ILOG adjusted
626 |       d7: k-factor/Unchanged
627 |       a0: pointer into memory for packed bcd string formation
628 |       a1: ptr to PTENxx array/Unchanged
629 |       a2: ptr to FP_SCR2(a6)/Unchanged
630 |       fp0: int portion of Y/abs(YINT) adjusted
631 |       fp1: 10^ISCALE/Unchanged
632 |       fp2: x/10^LEN
633 |       F_SCR1:x/x
634 |       F_SCR2:Y with original exponent/Unchanged
635 |       L_SCR1:original USER_FPCR/Unchanged
636 |       L_SCR2:first word of X packed/Unchanged
637
638 A13_st:
639         swap    %d5             |put ICTR in lower word of d5
640         tstw    %d5             |check if ICTR = 0
641         bne     not_zr          |if non-zero, go to second test
642 |
643 | Compute 10^(LEN-1)
644 |
645         fmoves  FONE,%fp2       |init fp2 to 1.0
646         movel   %d4,%d0         |put LEN in d0
647         subql   #1,%d0          |d0 = LEN -1
648         clrl    %d3             |clr table index
649 l_loop:
650         lsrl    #1,%d0          |shift next bit into carry
651         bccs    l_next          |if zero, skip the mul
652         fmulx   (%a1,%d3),%fp2  |mul by 10**(d3_bit_no)
653 l_next:
654         addl    #12,%d3         |inc d3 to next pwrten table entry
655         tstl    %d0             |test if LEN is zero
656         bnes    l_loop          |if not, loop
657 |
658 | 10^LEN-1 is computed for this test and A14.  If the input was
659 | denormalized, check only the case in which YINT > 10^LEN.
660 |
661         tstb    BINDEC_FLG(%a6) |check if input was norm
662         beqs    A13_con         |if norm, continue with checking
663         fabsx   %fp0            |take abs of YINT
664         bra     test_2
665 |
666 | Compare abs(YINT) to 10^(LEN-1) and 10^LEN
667 |
668 A13_con:
669         fabsx   %fp0            |take abs of YINT
670         fcmpx   %fp2,%fp0               |compare abs(YINT) with 10^(LEN-1)
671         fbge    test_2          |if greater, do next test
672         subql   #1,%d6          |subtract 1 from ILOG
673         movew   #1,%d5          |set ICTR
674         fmovel  #rm_mode,%FPCR  |set rmode to RM
675         fmuls   FTEN,%fp2       |compute 10^LEN
676         bra     A6_str          |return to A6 and recompute YINT
677 test_2:
678         fmuls   FTEN,%fp2       |compute 10^LEN
679         fcmpx   %fp2,%fp0               |compare abs(YINT) with 10^LEN
680         fblt    A14_st          |if less, all is ok, go to A14
681         fbgt    fix_ex          |if greater, fix and redo
682         fdivs   FTEN,%fp0       |if equal, divide by 10
683         addql   #1,%d6          | and inc ILOG
684         bras    A14_st          | and continue elsewhere
685 fix_ex:
686         addql   #1,%d6          |increment ILOG by 1
687         movew   #1,%d5          |set ICTR
688         fmovel  #rm_mode,%FPCR  |set rmode to RM
689         bra     A6_str          |return to A6 and recompute YINT
690 |
691 | Since ICTR <> 0, we have already been through one adjustment,
692 | and shouldn't have another; this is to check if abs(YINT) = 10^LEN
693 | 10^LEN is again computed using whatever table is in a1 since the
694 | value calculated cannot be inexact.
695 |
696 not_zr:
697         fmoves  FONE,%fp2       |init fp2 to 1.0
698         movel   %d4,%d0         |put LEN in d0
699         clrl    %d3             |clr table index
700 z_loop:
701         lsrl    #1,%d0          |shift next bit into carry
702         bccs    z_next          |if zero, skip the mul
703         fmulx   (%a1,%d3),%fp2  |mul by 10**(d3_bit_no)
704 z_next:
705         addl    #12,%d3         |inc d3 to next pwrten table entry
706         tstl    %d0             |test if LEN is zero
707         bnes    z_loop          |if not, loop
708         fabsx   %fp0            |get abs(YINT)
709         fcmpx   %fp2,%fp0               |check if abs(YINT) = 10^LEN
710         fbne    A14_st          |if not, skip this
711         fdivs   FTEN,%fp0       |divide abs(YINT) by 10
712         addql   #1,%d6          |and inc ILOG by 1
713         addql   #1,%d4          | and inc LEN
714         fmuls   FTEN,%fp2       | if LEN++, the get 10^^LEN
715
716
717 | A14. Convert the mantissa to bcd.
718 |      The binstr routine is used to convert the LEN digit
719 |      mantissa to bcd in memory.  The input to binstr is
720 |      to be a fraction; i.e. (mantissa)/10^LEN and adjusted
721 |      such that the decimal point is to the left of bit 63.
722 |      The bcd digits are stored in the correct position in
723 |      the final string area in memory.
724 |
725 |
726 | Register usage:
727 |       Input/Output
728 |       d0: x/LEN call to binstr - final is 0
729 |       d1: x/0
730 |       d2: x/ms 32-bits of mant of abs(YINT)
731 |       d3: x/ls 32-bits of mant of abs(YINT)
732 |       d4: LEN/Unchanged
733 |       d5: ICTR:LAMBDA/LAMBDA:ICTR
734 |       d6: ILOG
735 |       d7: k-factor/Unchanged
736 |       a0: pointer into memory for packed bcd string formation
737 |           /ptr to first mantissa byte in result string
738 |       a1: ptr to PTENxx array/Unchanged
739 |       a2: ptr to FP_SCR2(a6)/Unchanged
740 |       fp0: int portion of Y/abs(YINT) adjusted
741 |       fp1: 10^ISCALE/Unchanged
742 |       fp2: 10^LEN/Unchanged
743 |       F_SCR1:x/Work area for final result
744 |       F_SCR2:Y with original exponent/Unchanged
745 |       L_SCR1:original USER_FPCR/Unchanged
746 |       L_SCR2:first word of X packed/Unchanged
747
748 A14_st:
749         fmovel  #rz_mode,%FPCR  |force rz for conversion
750         fdivx   %fp2,%fp0               |divide abs(YINT) by 10^LEN
751         leal    FP_SCR1(%a6),%a0
752         fmovex  %fp0,(%a0)      |move abs(YINT)/10^LEN to memory
753         movel   4(%a0),%d2      |move 2nd word of FP_RES to d2
754         movel   8(%a0),%d3      |move 3rd word of FP_RES to d3
755         clrl    4(%a0)          |zero word 2 of FP_RES
756         clrl    8(%a0)          |zero word 3 of FP_RES
757         movel   (%a0),%d0               |move exponent to d0
758         swap    %d0             |put exponent in lower word
759         beqs    no_sft          |if zero, don't shift
760         subil   #0x3ffd,%d0     |sub bias less 2 to make fract
761         tstl    %d0             |check if > 1
762         bgts    no_sft          |if so, don't shift
763         negl    %d0             |make exp positive
764 m_loop:
765         lsrl    #1,%d2          |shift d2:d3 right, add 0s
766         roxrl   #1,%d3          |the number of places
767         dbf     %d0,m_loop      |given in d0
768 no_sft:
769         tstl    %d2             |check for mantissa of zero
770         bnes    no_zr           |if not, go on
771         tstl    %d3             |continue zero check
772         beqs    zer_m           |if zero, go directly to binstr
773 no_zr:
774         clrl    %d1             |put zero in d1 for addx
775         addil   #0x00000080,%d3 |inc at bit 7
776         addxl   %d1,%d2         |continue inc
777         andil   #0xffffff80,%d3 |strip off lsb not used by 882
778 zer_m:
779         movel   %d4,%d0         |put LEN in d0 for binstr call
780         addql   #3,%a0          |a0 points to M16 byte in result
781         bsr     binstr          |call binstr to convert mant
782
783
784 | A15. Convert the exponent to bcd.
785 |      As in A14 above, the exp is converted to bcd and the
786 |      digits are stored in the final string.
787 |
788 |      Digits are stored in L_SCR1(a6) on return from BINDEC as:
789 |
790 |        32               16 15                0
791 |       -----------------------------------------
792 |       |  0 | e3 | e2 | e1 | e4 |  X |  X |  X |
793 |       -----------------------------------------
794 |
795 | And are moved into their proper places in FP_SCR1.  If digit e4
796 | is non-zero, OPERR is signaled.  In all cases, all 4 digits are
797 | written as specified in the 881/882 manual for packed decimal.
798 |
799 | Register usage:
800 |       Input/Output
801 |       d0: x/LEN call to binstr - final is 0
802 |       d1: x/scratch (0);shift count for final exponent packing
803 |       d2: x/ms 32-bits of exp fraction/scratch
804 |       d3: x/ls 32-bits of exp fraction
805 |       d4: LEN/Unchanged
806 |       d5: ICTR:LAMBDA/LAMBDA:ICTR
807 |       d6: ILOG
808 |       d7: k-factor/Unchanged
809 |       a0: ptr to result string/ptr to L_SCR1(a6)
810 |       a1: ptr to PTENxx array/Unchanged
811 |       a2: ptr to FP_SCR2(a6)/Unchanged
812 |       fp0: abs(YINT) adjusted/float(ILOG)
813 |       fp1: 10^ISCALE/Unchanged
814 |       fp2: 10^LEN/Unchanged
815 |       F_SCR1:Work area for final result/BCD result
816 |       F_SCR2:Y with original exponent/ILOG/10^4
817 |       L_SCR1:original USER_FPCR/Exponent digits on return from binstr
818 |       L_SCR2:first word of X packed/Unchanged
819
820 A15_st:
821         tstb    BINDEC_FLG(%a6) |check for denorm
822         beqs    not_denorm
823         ftstx   %fp0            |test for zero
824         fbeq    den_zero        |if zero, use k-factor or 4933
825         fmovel  %d6,%fp0                |float ILOG
826         fabsx   %fp0            |get abs of ILOG
827         bras    convrt
828 den_zero:
829         tstl    %d7             |check sign of the k-factor
830         blts    use_ilog        |if negative, use ILOG
831         fmoves  F4933,%fp0      |force exponent to 4933
832         bras    convrt          |do it
833 use_ilog:
834         fmovel  %d6,%fp0                |float ILOG
835         fabsx   %fp0            |get abs of ILOG
836         bras    convrt
837 not_denorm:
838         ftstx   %fp0            |test for zero
839         fbne    not_zero        |if zero, force exponent
840         fmoves  FONE,%fp0       |force exponent to 1
841         bras    convrt          |do it
842 not_zero:
843         fmovel  %d6,%fp0                |float ILOG
844         fabsx   %fp0            |get abs of ILOG
845 convrt:
846         fdivx   24(%a1),%fp0    |compute ILOG/10^4
847         fmovex  %fp0,FP_SCR2(%a6)       |store fp0 in memory
848         movel   4(%a2),%d2      |move word 2 to d2
849         movel   8(%a2),%d3      |move word 3 to d3
850         movew   (%a2),%d0               |move exp to d0
851         beqs    x_loop_fin      |if zero, skip the shift
852         subiw   #0x3ffd,%d0     |subtract off bias
853         negw    %d0             |make exp positive
854 x_loop:
855         lsrl    #1,%d2          |shift d2:d3 right
856         roxrl   #1,%d3          |the number of places
857         dbf     %d0,x_loop      |given in d0
858 x_loop_fin:
859         clrl    %d1             |put zero in d1 for addx
860         addil   #0x00000080,%d3 |inc at bit 6
861         addxl   %d1,%d2         |continue inc
862         andil   #0xffffff80,%d3 |strip off lsb not used by 882
863         movel   #4,%d0          |put 4 in d0 for binstr call
864         leal    L_SCR1(%a6),%a0 |a0 is ptr to L_SCR1 for exp digits
865         bsr     binstr          |call binstr to convert exp
866         movel   L_SCR1(%a6),%d0 |load L_SCR1 lword to d0
867         movel   #12,%d1         |use d1 for shift count
868         lsrl    %d1,%d0         |shift d0 right by 12
869         bfins   %d0,FP_SCR1(%a6){#4:#12} |put e3:e2:e1 in FP_SCR1
870         lsrl    %d1,%d0         |shift d0 right by 12
871         bfins   %d0,FP_SCR1(%a6){#16:#4} |put e4 in FP_SCR1
872         tstb    %d0             |check if e4 is zero
873         beqs    A16_st          |if zero, skip rest
874         orl     #opaop_mask,USER_FPSR(%a6) |set OPERR & AIOP in USER_FPSR
875
876
877 | A16. Write sign bits to final string.
878 |          Sigma is bit 31 of initial value; RHO is bit 31 of d6 (ILOG).
879 |
880 | Register usage:
881 |       Input/Output
882 |       d0: x/scratch - final is x
883 |       d2: x/x
884 |       d3: x/x
885 |       d4: LEN/Unchanged
886 |       d5: ICTR:LAMBDA/LAMBDA:ICTR
887 |       d6: ILOG/ILOG adjusted
888 |       d7: k-factor/Unchanged
889 |       a0: ptr to L_SCR1(a6)/Unchanged
890 |       a1: ptr to PTENxx array/Unchanged
891 |       a2: ptr to FP_SCR2(a6)/Unchanged
892 |       fp0: float(ILOG)/Unchanged
893 |       fp1: 10^ISCALE/Unchanged
894 |       fp2: 10^LEN/Unchanged
895 |       F_SCR1:BCD result with correct signs
896 |       F_SCR2:ILOG/10^4
897 |       L_SCR1:Exponent digits on return from binstr
898 |       L_SCR2:first word of X packed/Unchanged
899
900 A16_st:
901         clrl    %d0             |clr d0 for collection of signs
902         andib   #0x0f,FP_SCR1(%a6) |clear first nibble of FP_SCR1
903         tstl    L_SCR2(%a6)     |check sign of original mantissa
904         bges    mant_p          |if pos, don't set SM
905         moveql  #2,%d0          |move 2 in to d0 for SM
906 mant_p:
907         tstl    %d6             |check sign of ILOG
908         bges    wr_sgn          |if pos, don't set SE
909         addql   #1,%d0          |set bit 0 in d0 for SE
910 wr_sgn:
911         bfins   %d0,FP_SCR1(%a6){#0:#2} |insert SM and SE into FP_SCR1
912
913 | Clean up and restore all registers used.
914
915         fmovel  #0,%FPSR                |clear possible inex2/ainex bits
916         fmovemx (%a7)+,%fp0-%fp2
917         moveml  (%a7)+,%d2-%d7/%a2
918         rts
919
920         |end