i386/linux-2.3.21/arch/arm/nwfpe/extended_cpdo.c

   1 /*
   2     NetWinder Floating Point Emulator
   3     (c) Rebel.com, 1998-1999
   4
   5     Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "config.h"
  23 #include "softfloat.h"
  24 #include "fpopcode.h"
  25 #include "fpa11.h"
  26
  27 floatx80 getExtendedConstant(unsigned int);
  28
  29 floatx80 floatx80_exp(floatx80 Fm);
  30 floatx80 floatx80_ln(floatx80 Fm);
  31 floatx80 floatx80_sin(floatx80 rFm);
  32 floatx80 floatx80_cos(floatx80 rFm);
  33 floatx80 floatx80_arcsin(floatx80 rFm);
  34 floatx80 floatx80_arctan(floatx80 rFm);
  35 floatx80 floatx80_log(floatx80 rFm);
  36 floatx80 floatx80_tan(floatx80 rFm);
  37 floatx80 floatx80_arccos(floatx80 rFm);
  38 floatx80 floatx80_pow(floatx80 rFn,floatx80 rFm);
  39 floatx80 floatx80_pol(floatx80 rFn,floatx80 rFm);
  40
  41 unsigned int ExtendedCPDO(const unsigned int opcode)
  42 {
  43    floatx80 rFm, rFn;
  44    unsigned int Fd, Fm, Fn, nRc = 1;
  45
  46    //fp_printk("ExtendedCPDO(0x%08x)\n",opcode);
  47
  48    Fm = getFm(opcode);
  49    if (CONSTANT_FM(opcode))
  50    {
  51      rFm = getExtendedConstant(Fm);
  52    }
  53    else
  54    {
  55      switch (fpa11->fpreg[Fm].fType)
  56      {
  57         case typeSingle:
  58           rFm = float32_to_floatx80(fpa11->fpreg[Fm].fValue.fSingle);
  59         break;
  60
  61         case typeDouble:
  62           rFm = float64_to_floatx80(fpa11->fpreg[Fm].fValue.fDouble);
  63         break;
  64
  65         case typeExtended:
  66           rFm = fpa11->fpreg[Fm].fValue.fExtended;
  67         break;
  68
  69         default: return 0;
  70      }
  71    }
  72
  73    if (!MONADIC_INSTRUCTION(opcode))
  74    {
  75       Fn = getFn(opcode);
  76       switch (fpa11->fpreg[Fn].fType)
  77       {
  78         case typeSingle:
  79           rFn = float32_to_floatx80(fpa11->fpreg[Fn].fValue.fSingle);
  80         break;
  81
  82         case typeDouble:
  83           rFn = float64_to_floatx80(fpa11->fpreg[Fn].fValue.fDouble);
  84         break;
  85
  86         case typeExtended:
  87           rFn = fpa11->fpreg[Fn].fValue.fExtended;
  88         break;
  89
  90         default: return 0;
  91       }
  92    }
  93
  94    Fd = getFd(opcode);
  95    switch (opcode & MASK_ARITHMETIC_OPCODE)
  96    {
  97       /* dyadic opcodes */
  98       case ADF_CODE:
  99          fpa11->fpreg[Fd].fValue.fExtended = floatx80_add(rFn,rFm);
 100       break;
 101
 102       case MUF_CODE:
 103       case FML_CODE:
 104          fpa11->fpreg[Fd].fValue.fExtended = floatx80_mul(rFn,rFm);
 105       break;
 106
 107       case SUF_CODE:
 108          fpa11->fpreg[Fd].fValue.fExtended = floatx80_sub(rFn,rFm);
 109       break;
 110
 111       case RSF_CODE:
 112          fpa11->fpreg[Fd].fValue.fExtended = floatx80_sub(rFm,rFn);
 113       break;
 114
 115       case DVF_CODE:
 116       case FDV_CODE:
 117          fpa11->fpreg[Fd].fValue.fExtended = floatx80_div(rFn,rFm);
 118       break;
 119
 120       case RDF_CODE:
 121       case FRD_CODE:
 122          fpa11->fpreg[Fd].fValue.fExtended = floatx80_div(rFm,rFn);
 123       break;
 124
 125 #if 0
 126       case POW_CODE:
 127          fpa11->fpreg[Fd].fValue.fExtended = floatx80_pow(rFn,rFm);
 128       break;
 129
 130       case RPW_CODE:
 131          fpa11->fpreg[Fd].fValue.fExtended = floatx80_pow(rFm,rFn);
 132       break;
 133 #endif
 134
 135       case RMF_CODE:
 136          fpa11->fpreg[Fd].fValue.fExtended = floatx80_rem(rFn,rFm);
 137       break;
 138
 139 #if 0
 140       case POL_CODE:
 141          fpa11->fpreg[Fd].fValue.fExtended = floatx80_pol(rFn,rFm);
 142       break;
 143 #endif
 144
 145       /* monadic opcodes */
 146       case MVF_CODE:
 147          fpa11->fpreg[Fd].fValue.fExtended = rFm;
 148       break;
 149
 150       case MNF_CODE:
 151          rFm.high ^= 0x8000;
 152          fpa11->fpreg[Fd].fValue.fExtended = rFm;
 153       break;
 154
 155       case ABS_CODE:
 156          rFm.high &= 0x7fff;
 157          fpa11->fpreg[Fd].fValue.fExtended = rFm;
 158       break;
 159
 160       case RND_CODE:
 161       case URD_CODE:
 162          fpa11->fpreg[Fd].fValue.fExtended =
 163              int32_to_floatx80(floatx80_to_int32(rFm));
 164       break;
 165
 166       case SQT_CODE:
 167          fpa11->fpreg[Fd].fValue.fExtended = floatx80_sqrt(rFm);
 168       break;
 169
 170 #if 0
 171       case LOG_CODE:
 172          fpa11->fpreg[Fd].fValue.fExtended = floatx80_log(rFm);
 173       break;
 174
 175       case LGN_CODE:
 176          fpa11->fpreg[Fd].fValue.fExtended = floatx80_ln(rFm);
 177       break;
 178
 179       case EXP_CODE:
 180          fpa11->fpreg[Fd].fValue.fExtended = floatx80_exp(rFm);
 181       break;
 182
 183       case SIN_CODE:
 184          fpa11->fpreg[Fd].fValue.fExtended = floatx80_sin(rFm);
 185       break;
 186
 187       case COS_CODE:
 188          fpa11->fpreg[Fd].fValue.fExtended = floatx80_cos(rFm);
 189       break;
 190
 191       case TAN_CODE:
 192          fpa11->fpreg[Fd].fValue.fExtended = floatx80_tan(rFm);
 193       break;
 194
 195       case ASN_CODE:
 196          fpa11->fpreg[Fd].fValue.fExtended = floatx80_arcsin(rFm);
 197       break;
 198
 199       case ACS_CODE:
 200          fpa11->fpreg[Fd].fValue.fExtended = floatx80_arccos(rFm);
 201       break;
 202
 203       case ATN_CODE:
 204          fpa11->fpreg[Fd].fValue.fExtended = floatx80_arctan(rFm);
 205       break;
 206 #endif
 207
 208       case NRM_CODE:
 209       break;
 210
 211       default:
 212       {
 213         nRc = 0;
 214       }
 215    }
 216
 217    if (0 != nRc) fpa11->fpreg[Fd].fType = typeExtended;
 218    return nRc;
 219 }
 220
 221 #if 0
 222 floatx80 floatx80_exp(floatx80 Fm)
 223 {
 224 //series
 225 }
 226
 227 floatx80 floatx80_ln(floatx80 Fm)
 228 {
 229 //series
 230 }
 231
 232 floatx80 floatx80_sin(floatx80 rFm)
 233 {
 234 //series
 235 }
 236
 237 floatx80 floatx80_cos(floatx80 rFm)
 238 {
 239 //series
 240 }
 241
 242 floatx80 floatx80_arcsin(floatx80 rFm)
 243 {
 244 //series
 245 }
 246
 247 floatx80 floatx80_arctan(floatx80 rFm)
 248 {
 249   //series
 250 }
 251
 252 floatx80 floatx80_log(floatx80 rFm)
 253 {
 254   return floatx80_div(floatx80_ln(rFm),getExtendedConstant(7));
 255 }
 256
 257 floatx80 floatx80_tan(floatx80 rFm)
 258 {
 259   return floatx80_div(floatx80_sin(rFm),floatx80_cos(rFm));
 260 }
 261
 262 floatx80 floatx80_arccos(floatx80 rFm)
 263 {
 264    //return floatx80_sub(halfPi,floatx80_arcsin(rFm));
 265 }
 266
 267 floatx80 floatx80_pow(floatx80 rFn,floatx80 rFm)
 268 {
 269   return floatx80_exp(floatx80_mul(rFm,floatx80_ln(rFn)));
 270 }
 271
 272 floatx80 floatx80_pol(floatx80 rFn,floatx80 rFm)
 273 {
 274   return floatx80_arctan(floatx80_div(rFn,rFm));
 275 }
 276 #endif