sys/arch/m68k/fpe/fpu_rem.c

   1 /*      $NetBSD: fpu_rem.c,v 1.8 2009/03/14 15:36:09 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.8 2009/03/14 15:36:09 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 }