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