Home | History | Annotate | Line # | Download | only in fpe
fpu_rem.c revision 1.9
      1 /*	$NetBSD: fpu_rem.c,v 1.9 2009/03/14 21:04:11 dsl Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1995  Ken Nakata
      5  *	All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the author nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)fpu_rem.c	10/24/95
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: fpu_rem.c,v 1.9 2009/03/14 21:04:11 dsl Exp $");
     36 
     37 #include <sys/types.h>
     38 #include <sys/signal.h>
     39 #include <machine/frame.h>
     40 
     41 #include "fpu_emulate.h"
     42 
     43 /*
     44  *       ALGORITHM
     45  *
     46  *       Step 1.  Save and strip signs of X and Y: signX := sign(X),
     47  *                signY := sign(Y), X := *X*, Y := *Y*,
     48  *                signQ := signX EOR signY. Record whether MOD or REM
     49  *                is requested.
     50  *
     51  *       Step 2.  Set L := expo(X)-expo(Y), k := 0, Q := 0.
     52  *                If (L < 0) then
     53  *                   R := X, go to Step 4.
     54  *                else
     55  *                   R := 2^(-L)X, j := L.
     56  *                endif
     57  *
     58  *       Step 3.  Perform MOD(X,Y)
     59  *            3.1 If R = Y, go to Step 9.
     60  *            3.2 If R > Y, then { R := R - Y, Q := Q + 1}
     61  *            3.3 If j = 0, go to Step 4.
     62  *            3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to
     63  *                Step 3.1.
     64  *
     65  *       Step 4.  At this point, R = X - QY = MOD(X,Y). Set
     66  *                Last_Subtract := false (used in Step 7 below). If
     67  *                MOD is requested, go to Step 6.
     68  *
     69  *       Step 5.  R = MOD(X,Y), but REM(X,Y) is requested.
     70  *            5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to
     71  *                Step 6.
     72  *            5.2 If R > Y/2, then { set Last_Subtract := true,
     73  *                Q := Q + 1, Y := signY*Y }. Go to Step 6.
     74  *            5.3 This is the tricky case of R = Y/2. If Q is odd,
     75  *                then { Q := Q + 1, signX := -signX }.
     76  *
     77  *       Step 6.  R := signX*R.
     78  *
     79  *       Step 7.  If Last_Subtract = true, R := R - Y.
     80  *
     81  *       Step 8.  Return signQ, last 7 bits of Q, and R as required.
     82  *
     83  *       Step 9.  At this point, R = 2^(-j)*X - Q Y = Y. Thus,
     84  *                X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1),
     85  *                R := 0. Return signQ, last 7 bits of Q, and R.
     86  */
     87 
     88 static struct fpn * __fpu_modrem(struct fpemu *fe, int modrem);
     89 
     90 static struct fpn *
     91 __fpu_modrem(struct fpemu *fe, int modrem)
     92 {
     93     static struct fpn X, Y;
     94     struct fpn *x, *y, *r;
     95     u_int signX, signY, signQ;
     96     int j, k, l, q;
     97     int Last_Subtract;
     98 
     99     CPYFPN(&X, &fe->fe_f1);
    100     CPYFPN(&Y, &fe->fe_f2);
    101     x = &X;
    102     y = &Y;
    103     r = &fe->fe_f2;
    104 
    105     /*
    106      * Step 1
    107      */
    108     signX = x->fp_sign;
    109     signY = y->fp_sign;
    110     signQ = (signX ^ signY);
    111     x->fp_sign = y->fp_sign = 0;
    112 
    113     /*
    114      * Step 2
    115      */
    116     l = x->fp_exp - y->fp_exp;
    117     k = 0;
    118     q = 0;
    119     if (l >= 0) {
    120 	CPYFPN(r, x);
    121 	r->fp_exp -= l;
    122 	j = l;
    123 
    124 	/*
    125 	 * Step 3
    126 	 */
    127 	while (y->fp_exp != r->fp_exp || y->fp_mant[0] != r->fp_mant[0] ||
    128 	       y->fp_mant[1] != r->fp_mant[1] ||
    129 	       y->fp_mant[2] != r->fp_mant[2]) {
    130 
    131 	    /* Step 3.2 */
    132 	    if (y->fp_exp < r->fp_exp || y->fp_mant[0] < r->fp_mant[0] ||
    133 		y->fp_mant[1] < r->fp_mant[1] ||
    134 		y->fp_mant[2] < r->fp_mant[2]) {
    135 		CPYFPN(&fe->fe_f1, r);
    136 		CPYFPN(&fe->fe_f2, y);
    137 		fe->fe_f2.fp_sign = 1;
    138 		r = fpu_add(fe);
    139 		q++;
    140 	    }
    141 
    142 	    /* Step 3.3 */
    143 	    if (j == 0)
    144 		goto Step4;
    145 
    146 	    /* Step 3.4 */
    147 	    k++;
    148 	    j--;
    149 	    q += q;
    150 	    r->fp_exp++;
    151 	}
    152 	/* Step 9 */
    153 	goto Step9;
    154     }
    155  Step4:
    156     Last_Subtract = 0;
    157     if (modrem == 0)
    158 	goto Step6;
    159 
    160     /*
    161      * Step 5
    162      */
    163     /* Step 5.1 */
    164     if (r->fp_exp + 1 < y->fp_exp ||
    165 	(r->fp_exp + 1 == y->fp_exp &&
    166 	 (r->fp_mant[0] < y->fp_mant[0] || r->fp_mant[1] < y->fp_mant[1] ||
    167 	  r->fp_mant[2] < y->fp_mant[2])))
    168 	/* if r < y/2 */
    169 	goto Step6;
    170     /* Step 5.2 */
    171     if (r->fp_exp + 1 != y->fp_exp ||
    172 	r->fp_mant[0] != y->fp_mant[0] || r->fp_mant[1] != y->fp_mant[1] ||
    173 	r->fp_mant[2] != y->fp_mant[2]) {
    174 	/* if (!(r < y/2) && !(r == y/2)) */
    175 	Last_Subtract = 1;
    176 	q++;
    177 	y->fp_sign = signY;
    178     } else {
    179 	/* Step 5.3 */
    180 	/* r == y/2 */
    181 	if (q % 2) {
    182 	    q++;
    183 	    signX = !signX;
    184 	}
    185     }
    186 
    187  Step6:
    188     r->fp_sign = signX;
    189 
    190     /*
    191      * Step 7
    192      */
    193     if (Last_Subtract) {
    194 	CPYFPN(&fe->fe_f1, r);
    195 	CPYFPN(&fe->fe_f2, y);
    196 	fe->fe_f2.fp_sign = !y->fp_sign;
    197 	r = fpu_add(fe);
    198     }
    199     /*
    200      * Step 8
    201      */
    202     q &= 0x7f;
    203     q |= (signQ << 7);
    204     fe->fe_fpframe->fpf_fpsr =
    205 	fe->fe_fpsr =
    206 	    (fe->fe_fpsr & ~FPSR_QTT) | (q << 16);
    207     return r;
    208 
    209  Step9:
    210     fe->fe_f1.fp_class = FPC_ZERO;
    211     q++;
    212     q &= 0x7f;
    213     q |= (signQ << 7);
    214     fe->fe_fpframe->fpf_fpsr =
    215 	fe->fe_fpsr =
    216 	    (fe->fe_fpsr & ~FPSR_QTT) | (q << 16);
    217     return &fe->fe_f1;
    218 }
    219 
    220 struct fpn *
    221 fpu_rem(struct fpemu *fe)
    222 {
    223   return __fpu_modrem(fe, 1);
    224 }
    225 
    226 struct fpn *
    227 fpu_mod(struct fpemu *fe)
    228 {
    229   return __fpu_modrem(fe, 0);
    230 }
    231