arch/arm/nwfpe/single_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 "softfloat.h"
  23 #include "fpopcode.h"
  24 #include "fpa11.h"
  25
  26 float32 getSingleConstant(unsigned int);
  27
  28 float32 float32_exp(float32 Fm);
  29 float32 float32_ln(float32 Fm);
  30 float32 float32_sin(float32 rFm);
  31 float32 float32_cos(float32 rFm);
  32 float32 float32_arcsin(float32 rFm);
  33 float32 float32_arctan(float32 rFm);
  34 float32 float32_log(float32 rFm);
  35 float32 float32_tan(float32 rFm);
  36 float32 float32_arccos(float32 rFm);
  37 float32 float32_pow(float32 rFn,float32 rFm);
  38 float32 float32_pol(float32 rFn,float32 rFm);
  39
  40 unsigned int SingleCPDO(const unsigned int opcode)
  41 {
  42    float32 rFm, rFn;
  43    unsigned int Fd, Fm, Fn, nRc = 1;
  44
  45    Fm = getFm(opcode);
  46    if (CONSTANT_FM(opcode))
  47    {
  48      rFm = getSingleConstant(Fm);
  49    }
  50    else
  51    {
  52      switch (fpa11->fType[Fm])
  53      {
  54         case typeSingle:
  55           rFm = fpa11->fpreg[Fm].fSingle;
  56         break;
  57
  58         default: return 0;
  59      }
  60    }
  61
  62    if (!MONADIC_INSTRUCTION(opcode))
  63    {
  64       Fn = getFn(opcode);
  65       switch (fpa11->fType[Fn])
  66       {
  67         case typeSingle:
  68           rFn = fpa11->fpreg[Fn].fSingle;
  69         break;
  70
  71         default: return 0;
  72       }
  73    }
  74
  75    Fd = getFd(opcode);
  76    switch (opcode & MASK_ARITHMETIC_OPCODE)
  77    {
  78       /* dyadic opcodes */
  79       case ADF_CODE:
  80          fpa11->fpreg[Fd].fSingle = float32_add(rFn,rFm);
  81       break;
  82
  83       case MUF_CODE:
  84       case FML_CODE:
  85         fpa11->fpreg[Fd].fSingle = float32_mul(rFn,rFm);
  86       break;
  87
  88       case SUF_CODE:
  89          fpa11->fpreg[Fd].fSingle = float32_sub(rFn,rFm);
  90       break;
  91
  92       case RSF_CODE:
  93          fpa11->fpreg[Fd].fSingle = float32_sub(rFm,rFn);
  94       break;
  95
  96       case DVF_CODE:
  97       case FDV_CODE:
  98          fpa11->fpreg[Fd].fSingle = float32_div(rFn,rFm);
  99       break;
 100
 101       case RDF_CODE:
 102       case FRD_CODE:
 103          fpa11->fpreg[Fd].fSingle = float32_div(rFm,rFn);
 104       break;
 105
 106 #if 0
 107       case POW_CODE:
 108          fpa11->fpreg[Fd].fSingle = float32_pow(rFn,rFm);
 109       break;
 110
 111       case RPW_CODE:
 112          fpa11->fpreg[Fd].fSingle = float32_pow(rFm,rFn);
 113       break;
 114 #endif
 115
 116       case RMF_CODE:
 117          fpa11->fpreg[Fd].fSingle = float32_rem(rFn,rFm);
 118       break;
 119
 120 #if 0
 121       case POL_CODE:
 122          fpa11->fpreg[Fd].fSingle = float32_pol(rFn,rFm);
 123       break;
 124 #endif
 125
 126       /* monadic opcodes */
 127       case MVF_CODE:
 128          fpa11->fpreg[Fd].fSingle = rFm;
 129       break;
 130
 131       case MNF_CODE:
 132          rFm ^= 0x80000000;
 133          fpa11->fpreg[Fd].fSingle = rFm;
 134       break;
 135
 136       case ABS_CODE:
 137          rFm &= 0x7fffffff;
 138          fpa11->fpreg[Fd].fSingle = rFm;
 139       break;
 140
 141       case RND_CODE:
 142       case URD_CODE:
 143          fpa11->fpreg[Fd].fSingle =
 144              int32_to_float32(float32_to_int32(rFm));
 145       break;
 146
 147       case SQT_CODE:
 148          fpa11->fpreg[Fd].fSingle = float32_sqrt(rFm);
 149       break;
 150
 151 #if 0
 152       case LOG_CODE:
 153          fpa11->fpreg[Fd].fSingle = float32_log(rFm);
 154       break;
 155
 156       case LGN_CODE:
 157          fpa11->fpreg[Fd].fSingle = float32_ln(rFm);
 158       break;
 159
 160       case EXP_CODE:
 161          fpa11->fpreg[Fd].fSingle = float32_exp(rFm);
 162       break;
 163
 164       case SIN_CODE:
 165          fpa11->fpreg[Fd].fSingle = float32_sin(rFm);
 166       break;
 167
 168       case COS_CODE:
 169          fpa11->fpreg[Fd].fSingle = float32_cos(rFm);
 170       break;
 171
 172       case TAN_CODE:
 173          fpa11->fpreg[Fd].fSingle = float32_tan(rFm);
 174       break;
 175
 176       case ASN_CODE:
 177          fpa11->fpreg[Fd].fSingle = float32_arcsin(rFm);
 178       break;
 179
 180       case ACS_CODE:
 181          fpa11->fpreg[Fd].fSingle = float32_arccos(rFm);
 182       break;
 183
 184       case ATN_CODE:
 185          fpa11->fpreg[Fd].fSingle = float32_arctan(rFm);
 186       break;
 187 #endif
 188
 189       case NRM_CODE:
 190       break;
 191
 192       default:
 193       {
 194         nRc = 0;
 195       }
 196    }
 197
 198    if (0 != nRc) fpa11->fType[Fd] = typeSingle;
 199    return nRc;
 200 }
 201
 202 #if 0
 203 float32 float32_exp(float32 Fm)
 204 {
 205 //series
 206 }
 207
 208 float32 float32_ln(float32 Fm)
 209 {
 210 //series
 211 }
 212
 213 float32 float32_sin(float32 rFm)
 214 {
 215 //series
 216 }
 217
 218 float32 float32_cos(float32 rFm)
 219 {
 220 //series
 221 }
 222
 223 float32 float32_arcsin(float32 rFm)
 224 {
 225 //series
 226 }
 227
 228 float32 float32_arctan(float32 rFm)
 229 {
 230   //series
 231 }
 232
 233 float32 float32_arccos(float32 rFm)
 234 {
 235    //return float32_sub(halfPi,float32_arcsin(rFm));
 236 }
 237
 238 float32 float32_log(float32 rFm)
 239 {
 240   return float32_div(float32_ln(rFm),getSingleConstant(7));
 241 }
 242
 243 float32 float32_tan(float32 rFm)
 244 {
 245   return float32_div(float32_sin(rFm),float32_cos(rFm));
 246 }
 247
 248 float32 float32_pow(float32 rFn,float32 rFm)
 249 {
 250   return float32_exp(float32_mul(rFm,float32_ln(rFn)));
 251 }
 252
 253 float32 float32_pol(float32 rFn,float32 rFm)
 254 {
 255   return float32_arctan(float32_div(rFn,rFm));
 256 }
 257 #endif