Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 506 insertions, 0 deletions

diff --git a/arch/m68k/fpsp040/decbin.S b/arch/m68k/fpsp040/decbin.S
new file mode 100644
index 000000000000..2160609e328d
--- /dev/null
+++ b/arch/m68k/fpsp040/decbin.S
@@ -0,0 +1,506 @@
+|
+|       decbin.sa 3.3 12/19/90
+|
+|       Description: Converts normalized packed bcd value pointed to by
+|       register A6 to extended-precision value in FP0.
+|
+|       Input: Normalized packed bcd value in ETEMP(a6).
+|
+|       Output: Exact floating-point representation of the packed bcd value.
+|
+|       Saves and Modifies: D2-D5
+|
+|       Speed: The program decbin takes ??? cycles to execute.
+|
+|       Object Size:
+|
+|       External Reference(s): None.
+|
+|       Algorithm:
+|       Expected is a normal bcd (i.e. non-exceptional; all inf, zero,
+|       and NaN operands are dispatched without entering this routine)
+|       value in 68881/882 format at location ETEMP(A6).
+|
+|       A1.     Convert the bcd exponent to binary by successive adds and muls.
+|       Set the sign according to SE. Subtract 16 to compensate
+|       for the mantissa which is to be interpreted as 17 integer
+|       digits, rather than 1 integer and 16 fraction digits.
+|       Note: this operation can never overflow.
+|
+|       A2. Convert the bcd mantissa to binary by successive
+|       adds and muls in FP0. Set the sign according to SM.
+|       The mantissa digits will be converted with the decimal point
+|       assumed following the least-significant digit.
+|       Note: this operation can never overflow.
+|
+|       A3. Count the number of leading/trailing zeros in the
+|       bcd string.  If SE is positive, count the leading zeros;
+|       if negative, count the trailing zeros.  Set the adjusted
+|       exponent equal to the exponent from A1 and the zero count
+|       added if SM = 1 and subtracted if SM = 0.  Scale the
+|       mantissa the equivalent of forcing in the bcd value:
+|
+|       SM = 0  a non-zero digit in the integer position
+|       SM = 1  a non-zero digit in Mant0, lsd of the fraction
+|
+|       this will insure that any value, regardless of its
+|       representation (ex. 0.1E2, 1E1, 10E0, 100E-1), is converted
+|       consistently.
+|
+|       A4. Calculate the factor 10^exp in FP1 using a table of
+|       10^(2^n) values.  To reduce the error in forming factors
+|       greater than 10^27, a directed rounding scheme is used with
+|       tables rounded to RN, RM, and RP, according to the table
+|       in the comments of the pwrten section.
+|
+|       A5. Form the final binary number by scaling the mantissa by
+|       the exponent factor.  This is done by multiplying the
+|       mantissa in FP0 by the factor in FP1 if the adjusted
+|       exponent sign is positive, and dividing FP0 by FP1 if
+|       it is negative.
+|
+|       Clean up and return.  Check if the final mul or div resulted
+|       in an inex2 exception.  If so, set inex1 in the fpsr and
+|       check if the inex1 exception is enabled.  If so, set d7 upper
+|       word to $0100.  This will signal unimp.sa that an enabled inex1
+|       exception occurred.  Unimp will fix the stack.
+|
+
+|               Copyright (C) Motorola, Inc. 1990
+|                       All Rights Reserved
+|
+|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
+|       The copyright notice above does not evidence any
+|       actual or intended publication of such source code.
+
+|DECBIN    idnt    2,1 | Motorola 040 Floating Point Software Package
+
+        |section        8
+
+#include "fpsp.h"
+
+|
+|       PTENRN, PTENRM, and PTENRP are arrays of powers of 10 rounded
+|       to nearest, minus, and plus, respectively.  The tables include
+|       10**{1,2,4,8,16,32,64,128,256,512,1024,2048,4096}.  No rounding
+|       is required until the power is greater than 27, however, all
+|       tables include the first 5 for ease of indexing.
+|
+        |xref   PTENRN
+        |xref   PTENRM
+        |xref   PTENRP
+
+RTABLE: .byte   0,0,0,0
+        .byte   2,3,2,3
+        .byte   2,3,3,2
+        .byte   3,2,2,3
+
+        .global decbin
+        .global calc_e
+        .global pwrten
+        .global calc_m
+        .global norm
+        .global ap_st_z
+        .global ap_st_n
+|
+        .set    FNIBS,7
+        .set    FSTRT,0
+|
+        .set    ESTRT,4
+        .set    EDIGITS,2       |
+|
+| Constants in single precision
+FZERO:  .long   0x00000000
+FONE:   .long   0x3F800000
+FTEN:   .long   0x41200000
+
+        .set    TEN,10
+
+|
+decbin:
+        | fmovel        #0,FPCR         ;clr real fpcr
+        moveml  %d2-%d5,-(%a7)
+|
+| Calculate exponent:
+|  1. Copy bcd value in memory for use as a working copy.
+|  2. Calculate absolute value of exponent in d1 by mul and add.
+|  3. Correct for exponent sign.
+|  4. Subtract 16 to compensate for interpreting the mant as all integer digits.
+|     (i.e., all digits assumed left of the decimal point.)
+|
+| Register usage:
+|
+|  calc_e:
+|       (*)  d0: temp digit storage
+|       (*)  d1: accumulator for binary exponent
+|       (*)  d2: digit count
+|       (*)  d3: offset pointer
+|       ( )  d4: first word of bcd
+|       ( )  a0: pointer to working bcd value
+|       ( )  a6: pointer to original bcd value
+|       (*)  FP_SCR1: working copy of original bcd value
+|       (*)  L_SCR1: copy of original exponent word
+|
+calc_e:
+        movel   #EDIGITS,%d2    |# of nibbles (digits) in fraction part
+        moveql  #ESTRT,%d3      |counter to pick up digits
+        leal    FP_SCR1(%a6),%a0        |load tmp bcd storage address
+        movel   ETEMP(%a6),(%a0)        |save input bcd value
+        movel   ETEMP_HI(%a6),4(%a0) |save words 2 and 3
+        movel   ETEMP_LO(%a6),8(%a0) |and work with these
+        movel   (%a0),%d4       |get first word of bcd
+        clrl    %d1             |zero d1 for accumulator
+e_gd:
+        mulul   #TEN,%d1        |mul partial product by one digit place
+        bfextu  %d4{%d3:#4},%d0 |get the digit and zero extend into d0
+        addl    %d0,%d1         |d1 = d1 + d0
+        addqb   #4,%d3          |advance d3 to the next digit
+        dbf     %d2,e_gd        |if we have used all 3 digits, exit loop
+        btst    #30,%d4         |get SE
+        beqs    e_pos           |don't negate if pos
+        negl    %d1             |negate before subtracting
+e_pos:
+        subl    #16,%d1         |sub to compensate for shift of mant
+        bges    e_save          |if still pos, do not neg
+        negl    %d1             |now negative, make pos and set SE
+        orl     #0x40000000,%d4 |set SE in d4,
+        orl     #0x40000000,(%a0)       |and in working bcd
+e_save:
+        movel   %d1,L_SCR1(%a6) |save exp in memory
+|
+|
+| Calculate mantissa:
+|  1. Calculate absolute value of mantissa in fp0 by mul and add.
+|  2. Correct for mantissa sign.
+|     (i.e., all digits assumed left of the decimal point.)
+|
+| Register usage:
+|
+|  calc_m:
+|       (*)  d0: temp digit storage
+|       (*)  d1: lword counter
+|       (*)  d2: digit count
+|       (*)  d3: offset pointer
+|       ( )  d4: words 2 and 3 of bcd
+|       ( )  a0: pointer to working bcd value
+|       ( )  a6: pointer to original bcd value
+|       (*) fp0: mantissa accumulator
+|       ( )  FP_SCR1: working copy of original bcd value
+|       ( )  L_SCR1: copy of original exponent word
+|
+calc_m:
+        moveql  #1,%d1          |word counter, init to 1
+        fmoves  FZERO,%fp0      |accumulator
+|
+|
+|  Since the packed number has a long word between the first & second parts,
+|  get the integer digit then skip down & get the rest of the
+|  mantissa.  We will unroll the loop once.
+|
+        bfextu  (%a0){#28:#4},%d0       |integer part is ls digit in long word
+        faddb   %d0,%fp0                |add digit to sum in fp0
+|
+|
+|  Get the rest of the mantissa.
+|
+loadlw:
+        movel   (%a0,%d1.L*4),%d4       |load mantissa longword into d4
+        moveql  #FSTRT,%d3      |counter to pick up digits
+        moveql  #FNIBS,%d2      |reset number of digits per a0 ptr
+md2b:
+        fmuls   FTEN,%fp0       |fp0 = fp0 * 10
+        bfextu  %d4{%d3:#4},%d0 |get the digit and zero extend
+        faddb   %d0,%fp0        |fp0 = fp0 + digit
+|
+|
+|  If all the digits (8) in that long word have been converted (d2=0),
+|  then inc d1 (=2) to point to the next long word and reset d3 to 0
+|  to initialize the digit offset, and set d2 to 7 for the digit count;
+|  else continue with this long word.
+|
+        addqb   #4,%d3          |advance d3 to the next digit
+        dbf     %d2,md2b                |check for last digit in this lw
+nextlw:
+        addql   #1,%d1          |inc lw pointer in mantissa
+        cmpl    #2,%d1          |test for last lw
+        ble     loadlw          |if not, get last one
+
+|
+|  Check the sign of the mant and make the value in fp0 the same sign.
+|
+m_sign:
+        btst    #31,(%a0)       |test sign of the mantissa
+        beq     ap_st_z         |if clear, go to append/strip zeros
+        fnegx   %fp0            |if set, negate fp0
+
+|
+| Append/strip zeros:
+|
+|  For adjusted exponents which have an absolute value greater than 27*,
+|  this routine calculates the amount needed to normalize the mantissa
+|  for the adjusted exponent.  That number is subtracted from the exp
+|  if the exp was positive, and added if it was negative.  The purpose
+|  of this is to reduce the value of the exponent and the possibility
+|  of error in calculation of pwrten.
+|
+|  1. Branch on the sign of the adjusted exponent.
+|  2p.(positive exp)
+|   2. Check M16 and the digits in lwords 2 and 3 in descending order.
+|   3. Add one for each zero encountered until a non-zero digit.
+|   4. Subtract the count from the exp.
+|   5. Check if the exp has crossed zero in #3 above; make the exp abs
+|          and set SE.
+|       6. Multiply the mantissa by 10**count.
+|  2n.(negative exp)
+|   2. Check the digits in lwords 3 and 2 in descending order.
+|   3. Add one for each zero encountered until a non-zero digit.
+|   4. Add the count to the exp.
+|   5. Check if the exp has crossed zero in #3 above; clear SE.
+|   6. Divide the mantissa by 10**count.
+|
+|  *Why 27?  If the adjusted exponent is within -28 < expA < 28, than
+|   any adjustment due to append/strip zeros will drive the resultant
+|   exponent towards zero.  Since all pwrten constants with a power
+|   of 27 or less are exact, there is no need to use this routine to
+|   attempt to lessen the resultant exponent.
+|
+| Register usage:
+|
+|  ap_st_z:
+|       (*)  d0: temp digit storage
+|       (*)  d1: zero count
+|       (*)  d2: digit count
+|       (*)  d3: offset pointer
+|       ( )  d4: first word of bcd
+|       (*)  d5: lword counter
+|       ( )  a0: pointer to working bcd value
+|       ( )  FP_SCR1: working copy of original bcd value
+|       ( )  L_SCR1: copy of original exponent word
+|
+|
+| First check the absolute value of the exponent to see if this
+| routine is necessary.  If so, then check the sign of the exponent
+| and do append (+) or strip (-) zeros accordingly.
+| This section handles a positive adjusted exponent.
+|
+ap_st_z:
+        movel   L_SCR1(%a6),%d1 |load expA for range test
+        cmpl    #27,%d1         |test is with 27
+        ble     pwrten          |if abs(expA) <28, skip ap/st zeros
+        btst    #30,(%a0)       |check sign of exp
+        bne     ap_st_n         |if neg, go to neg side
+        clrl    %d1             |zero count reg
+        movel   (%a0),%d4               |load lword 1 to d4
+        bfextu  %d4{#28:#4},%d0 |get M16 in d0
+        bnes    ap_p_fx         |if M16 is non-zero, go fix exp
+        addql   #1,%d1          |inc zero count
+        moveql  #1,%d5          |init lword counter
+        movel   (%a0,%d5.L*4),%d4       |get lword 2 to d4
+        bnes    ap_p_cl         |if lw 2 is zero, skip it
+        addql   #8,%d1          |and inc count by 8
+        addql   #1,%d5          |inc lword counter
+        movel   (%a0,%d5.L*4),%d4       |get lword 3 to d4
+ap_p_cl:
+        clrl    %d3             |init offset reg
+        moveql  #7,%d2          |init digit counter
+ap_p_gd:
+        bfextu  %d4{%d3:#4},%d0 |get digit
+        bnes    ap_p_fx         |if non-zero, go to fix exp
+        addql   #4,%d3          |point to next digit
+        addql   #1,%d1          |inc digit counter
+        dbf     %d2,ap_p_gd     |get next digit
+ap_p_fx:
+        movel   %d1,%d0         |copy counter to d2
+        movel   L_SCR1(%a6),%d1 |get adjusted exp from memory
+        subl    %d0,%d1         |subtract count from exp
+        bges    ap_p_fm         |if still pos, go to pwrten
+        negl    %d1             |now its neg; get abs
+        movel   (%a0),%d4               |load lword 1 to d4
+        orl     #0x40000000,%d4 | and set SE in d4
+        orl     #0x40000000,(%a0)       | and in memory
+|
+| Calculate the mantissa multiplier to compensate for the striping of
+| zeros from the mantissa.
+|
+ap_p_fm:
+        movel   #PTENRN,%a1     |get address of power-of-ten table
+        clrl    %d3             |init table index
+        fmoves  FONE,%fp1       |init fp1 to 1
+        moveql  #3,%d2          |init d2 to count bits in counter
+ap_p_el:
+        asrl    #1,%d0          |shift lsb into carry
+        bccs    ap_p_en         |if 1, mul fp1 by pwrten factor
+        fmulx   (%a1,%d3),%fp1  |mul by 10**(d3_bit_no)
+ap_p_en:
+        addl    #12,%d3         |inc d3 to next rtable entry
+        tstl    %d0             |check if d0 is zero
+        bnes    ap_p_el         |if not, get next bit
+        fmulx   %fp1,%fp0               |mul mantissa by 10**(no_bits_shifted)
+        bra     pwrten          |go calc pwrten
+|
+| This section handles a negative adjusted exponent.
+|
+ap_st_n:
+        clrl    %d1             |clr counter
+        moveql  #2,%d5          |set up d5 to point to lword 3
+        movel   (%a0,%d5.L*4),%d4       |get lword 3
+        bnes    ap_n_cl         |if not zero, check digits
+        subl    #1,%d5          |dec d5 to point to lword 2
+        addql   #8,%d1          |inc counter by 8
+        movel   (%a0,%d5.L*4),%d4       |get lword 2
+ap_n_cl:
+        movel   #28,%d3         |point to last digit
+        moveql  #7,%d2          |init digit counter
+ap_n_gd:
+        bfextu  %d4{%d3:#4},%d0 |get digit
+        bnes    ap_n_fx         |if non-zero, go to exp fix
+        subql   #4,%d3          |point to previous digit
+        addql   #1,%d1          |inc digit counter
+        dbf     %d2,ap_n_gd     |get next digit
+ap_n_fx:
+        movel   %d1,%d0         |copy counter to d0
+        movel   L_SCR1(%a6),%d1 |get adjusted exp from memory
+        subl    %d0,%d1         |subtract count from exp
+        bgts    ap_n_fm         |if still pos, go fix mantissa
+        negl    %d1             |take abs of exp and clr SE
+        movel   (%a0),%d4               |load lword 1 to d4
+        andl    #0xbfffffff,%d4 | and clr SE in d4
+        andl    #0xbfffffff,(%a0)       | and in memory
+|
+| Calculate the mantissa multiplier to compensate for the appending of
+| zeros to the mantissa.
+|
+ap_n_fm:
+        movel   #PTENRN,%a1     |get address of power-of-ten table
+        clrl    %d3             |init table index
+        fmoves  FONE,%fp1       |init fp1 to 1
+        moveql  #3,%d2          |init d2 to count bits in counter
+ap_n_el:
+        asrl    #1,%d0          |shift lsb into carry
+        bccs    ap_n_en         |if 1, mul fp1 by pwrten factor
+        fmulx   (%a1,%d3),%fp1  |mul by 10**(d3_bit_no)
+ap_n_en:
+        addl    #12,%d3         |inc d3 to next rtable entry
+        tstl    %d0             |check if d0 is zero
+        bnes    ap_n_el         |if not, get next bit
+        fdivx   %fp1,%fp0               |div mantissa by 10**(no_bits_shifted)
+|
+|
+| Calculate power-of-ten factor from adjusted and shifted exponent.
+|
+| Register usage:
+|
+|  pwrten:
+|       (*)  d0: temp
+|       ( )  d1: exponent
+|       (*)  d2: {FPCR[6:5],SM,SE} as index in RTABLE; temp
+|       (*)  d3: FPCR work copy
+|       ( )  d4: first word of bcd
+|       (*)  a1: RTABLE pointer
+|  calc_p:
+|       (*)  d0: temp
+|       ( )  d1: exponent
+|       (*)  d3: PWRTxx table index
+|       ( )  a0: pointer to working copy of bcd
+|       (*)  a1: PWRTxx pointer
+|       (*) fp1: power-of-ten accumulator
+|
+| Pwrten calculates the exponent factor in the selected rounding mode
+| according to the following table:
+|
+|       Sign of Mant  Sign of Exp  Rounding Mode  PWRTEN Rounding Mode
+|
+|       ANY       ANY   RN      RN
+|
+|        +         +    RP      RP
+|        -         +    RP      RM
+|        +         -    RP      RM
+|        -         -    RP      RP
+|
+|        +         +    RM      RM
+|        -         +    RM      RP
+|        +         -    RM      RP
+|        -         -    RM      RM
+|
+|        +         +    RZ      RM
+|        -         +    RZ      RM
+|        +         -    RZ      RP
+|        -         -    RZ      RP
+|
+|
+pwrten:
+        movel   USER_FPCR(%a6),%d3 |get user's FPCR
+        bfextu  %d3{#26:#2},%d2 |isolate rounding mode bits
+        movel   (%a0),%d4               |reload 1st bcd word to d4
+        asll    #2,%d2          |format d2 to be
+        bfextu  %d4{#0:#2},%d0  | {FPCR[6],FPCR[5],SM,SE}
+        addl    %d0,%d2         |in d2 as index into RTABLE
+        leal    RTABLE,%a1      |load rtable base
+        moveb   (%a1,%d2),%d0   |load new rounding bits from table
+        clrl    %d3                     |clear d3 to force no exc and extended
+        bfins   %d0,%d3{#26:#2} |stuff new rounding bits in FPCR
+        fmovel  %d3,%FPCR               |write new FPCR
+        asrl    #1,%d0          |write correct PTENxx table
+        bccs    not_rp          |to a1
+        leal    PTENRP,%a1      |it is RP
+        bras    calc_p          |go to init section
+not_rp:
+        asrl    #1,%d0          |keep checking
+        bccs    not_rm
+        leal    PTENRM,%a1      |it is RM
+        bras    calc_p          |go to init section
+not_rm:
+        leal    PTENRN,%a1      |it is RN
+calc_p:
+        movel   %d1,%d0         |copy exp to d0;use d0
+        bpls    no_neg          |if exp is negative,
+        negl    %d0             |invert it
+        orl     #0x40000000,(%a0)       |and set SE bit
+no_neg:
+        clrl    %d3             |table index
+        fmoves  FONE,%fp1       |init fp1 to 1
+e_loop:
+        asrl    #1,%d0          |shift next bit into carry
+        bccs    e_next          |if zero, skip the mul
+        fmulx   (%a1,%d3),%fp1  |mul by 10**(d3_bit_no)
+e_next:
+        addl    #12,%d3         |inc d3 to next rtable entry
+        tstl    %d0             |check if d0 is zero
+        bnes    e_loop          |not zero, continue shifting
+|
+|
+|  Check the sign of the adjusted exp and make the value in fp0 the
+|  same sign. If the exp was pos then multiply fp1*fp0;
+|  else divide fp0/fp1.
+|
+| Register Usage:
+|  norm:
+|       ( )  a0: pointer to working bcd value
+|       (*) fp0: mantissa accumulator
+|       ( ) fp1: scaling factor - 10**(abs(exp))
+|
+norm:
+        btst    #30,(%a0)       |test the sign of the exponent
+        beqs    mul             |if clear, go to multiply
+div:
+        fdivx   %fp1,%fp0               |exp is negative, so divide mant by exp
+        bras    end_dec
+mul:
+        fmulx   %fp1,%fp0               |exp is positive, so multiply by exp
+|
+|
+| Clean up and return with result in fp0.
+|
+| If the final mul/div in decbin incurred an inex exception,
+| it will be inex2, but will be reported as inex1 by get_op.
+|
+end_dec:
+        fmovel  %FPSR,%d0               |get status register
+        bclrl   #inex2_bit+8,%d0        |test for inex2 and clear it
+        fmovel  %d0,%FPSR               |return status reg w/o inex2
+        beqs    no_exc          |skip this if no exc
+        orl     #inx1a_mask,USER_FPSR(%a6) |set inex1/ainex
+no_exc:
+        moveml  (%a7)+,%d2-%d5
+        rts
+        |end