Statistics
| Branch: | Revision:

root / target-arm / nwfpe / extended_cpdo.c @ 5fafdf24

History | View | Annotate | Download (6.1 kB)

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 "fpa11.h"
23
#include "softfloat.h"
24
#include "fpopcode.h"
25

    
26
floatx80 floatx80_exp(floatx80 Fm);
27
floatx80 floatx80_ln(floatx80 Fm);
28
floatx80 floatx80_sin(floatx80 rFm);
29
floatx80 floatx80_cos(floatx80 rFm);
30
floatx80 floatx80_arcsin(floatx80 rFm);
31
floatx80 floatx80_arctan(floatx80 rFm);
32
floatx80 floatx80_log(floatx80 rFm);
33
floatx80 floatx80_tan(floatx80 rFm);
34
floatx80 floatx80_arccos(floatx80 rFm);
35
floatx80 floatx80_pow(floatx80 rFn,floatx80 rFm);
36
floatx80 floatx80_pol(floatx80 rFn,floatx80 rFm);
37

    
38
unsigned int ExtendedCPDO(const unsigned int opcode)
39
{
40
   FPA11 *fpa11 = GET_FPA11();
41
   floatx80 rFm, rFn;
42
   unsigned int Fd, Fm, Fn, nRc = 1;
43

    
44
   //printk("ExtendedCPDO(0x%08x)\n",opcode);
45
  
46
   Fm = getFm(opcode);
47
   if (CONSTANT_FM(opcode))
48
   {
49
     rFm = getExtendedConstant(Fm);
50
   }
51
   else
52
   { 
53
     switch (fpa11->fType[Fm])
54
     {
55
        case typeSingle:
56
          rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle, &fpa11->fp_status);
57
        break;
58

    
59
        case typeDouble:
60
          rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble, &fpa11->fp_status);
61
        break;
62
       
63
        case typeExtended:
64
          rFm = fpa11->fpreg[Fm].fExtended;
65
        break;
66
       
67
        default: return 0;
68
     }
69
   }
70
  
71
   if (!MONADIC_INSTRUCTION(opcode))
72
   {
73
      Fn = getFn(opcode);
74
      switch (fpa11->fType[Fn])
75
      {
76
        case typeSingle:
77
          rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status);
78
        break;
79

    
80
        case typeDouble:
81
          rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble, &fpa11->fp_status);
82
        break;
83
       
84
        case typeExtended:
85
          rFn = fpa11->fpreg[Fn].fExtended;
86
        break;
87
       
88
        default: return 0;
89
      }
90
   }
91

    
92
   Fd = getFd(opcode);
93
   switch (opcode & MASK_ARITHMETIC_OPCODE)
94
   {
95
      /* dyadic opcodes */
96
      case ADF_CODE:
97
         fpa11->fpreg[Fd].fExtended = floatx80_add(rFn,rFm, &fpa11->fp_status);
98
      break;
99

    
100
      case MUF_CODE:
101
      case FML_CODE:
102
         fpa11->fpreg[Fd].fExtended = floatx80_mul(rFn,rFm, &fpa11->fp_status);
103
      break;
104

    
105
      case SUF_CODE:
106
         fpa11->fpreg[Fd].fExtended = floatx80_sub(rFn,rFm, &fpa11->fp_status);
107
      break;
108

    
109
      case RSF_CODE:
110
         fpa11->fpreg[Fd].fExtended = floatx80_sub(rFm,rFn, &fpa11->fp_status);
111
      break;
112

    
113
      case DVF_CODE:
114
      case FDV_CODE:
115
         fpa11->fpreg[Fd].fExtended = floatx80_div(rFn,rFm, &fpa11->fp_status);
116
      break;
117

    
118
      case RDF_CODE:
119
      case FRD_CODE:
120
         fpa11->fpreg[Fd].fExtended = floatx80_div(rFm,rFn, &fpa11->fp_status);
121
      break;
122

    
123
#if 0
124
      case POW_CODE:
125
         fpa11->fpreg[Fd].fExtended = floatx80_pow(rFn,rFm);
126
      break;
127

128
      case RPW_CODE:
129
         fpa11->fpreg[Fd].fExtended = floatx80_pow(rFm,rFn);
130
      break;
131
#endif
132

    
133
      case RMF_CODE:
134
         fpa11->fpreg[Fd].fExtended = floatx80_rem(rFn,rFm, &fpa11->fp_status);
135
      break;
136

    
137
#if 0
138
      case POL_CODE:
139
         fpa11->fpreg[Fd].fExtended = floatx80_pol(rFn,rFm);
140
      break;
141
#endif
142

    
143
      /* monadic opcodes */
144
      case MVF_CODE:
145
         fpa11->fpreg[Fd].fExtended = rFm;
146
      break;
147

    
148
      case MNF_CODE:
149
         rFm.high ^= 0x8000;
150
         fpa11->fpreg[Fd].fExtended = rFm;
151
      break;
152

    
153
      case ABS_CODE:
154
         rFm.high &= 0x7fff;
155
         fpa11->fpreg[Fd].fExtended = rFm;
156
      break;
157

    
158
      case RND_CODE:
159
      case URD_CODE:
160
         fpa11->fpreg[Fd].fExtended = floatx80_round_to_int(rFm, &fpa11->fp_status);
161
      break;
162

    
163
      case SQT_CODE:
164
         fpa11->fpreg[Fd].fExtended = floatx80_sqrt(rFm, &fpa11->fp_status);
165
      break;
166

    
167
#if 0
168
      case LOG_CODE:
169
         fpa11->fpreg[Fd].fExtended = floatx80_log(rFm);
170
      break;
171

172
      case LGN_CODE:
173
         fpa11->fpreg[Fd].fExtended = floatx80_ln(rFm);
174
      break;
175

176
      case EXP_CODE:
177
         fpa11->fpreg[Fd].fExtended = floatx80_exp(rFm);
178
      break;
179

180
      case SIN_CODE:
181
         fpa11->fpreg[Fd].fExtended = floatx80_sin(rFm);
182
      break;
183

184
      case COS_CODE:
185
         fpa11->fpreg[Fd].fExtended = floatx80_cos(rFm);
186
      break;
187

188
      case TAN_CODE:
189
         fpa11->fpreg[Fd].fExtended = floatx80_tan(rFm);
190
      break;
191

192
      case ASN_CODE:
193
         fpa11->fpreg[Fd].fExtended = floatx80_arcsin(rFm);
194
      break;
195

196
      case ACS_CODE:
197
         fpa11->fpreg[Fd].fExtended = floatx80_arccos(rFm);
198
      break;
199

200
      case ATN_CODE:
201
         fpa11->fpreg[Fd].fExtended = floatx80_arctan(rFm);
202
      break;
203
#endif
204

    
205
      case NRM_CODE:
206
      break;
207
     
208
      default:
209
      {
210
        nRc = 0;
211
      }
212
   }
213
  
214
   if (0 != nRc) fpa11->fType[Fd] = typeExtended;
215
   return nRc;
216
}
217

    
218
#if 0
219
floatx80 floatx80_exp(floatx80 Fm)
220
{
221
//series
222
}
223

224
floatx80 floatx80_ln(floatx80 Fm)
225
{
226
//series
227
}
228

229
floatx80 floatx80_sin(floatx80 rFm)
230
{
231
//series
232
}
233

234
floatx80 floatx80_cos(floatx80 rFm)
235
{
236
//series
237
}
238

239
floatx80 floatx80_arcsin(floatx80 rFm)
240
{
241
//series
242
}
243

244
floatx80 floatx80_arctan(floatx80 rFm)
245
{
246
  //series
247
}
248

249
floatx80 floatx80_log(floatx80 rFm)
250
{
251
  return floatx80_div(floatx80_ln(rFm),getExtendedConstant(7));
252
}
253

254
floatx80 floatx80_tan(floatx80 rFm)
255
{
256
  return floatx80_div(floatx80_sin(rFm),floatx80_cos(rFm));
257
}
258

259
floatx80 floatx80_arccos(floatx80 rFm)
260
{
261
   //return floatx80_sub(halfPi,floatx80_arcsin(rFm));
262
}
263

264
floatx80 floatx80_pow(floatx80 rFn,floatx80 rFm)
265
{
266
  return floatx80_exp(floatx80_mul(rFm,floatx80_ln(rFn)));
267
}
268

269
floatx80 floatx80_pol(floatx80 rFn,floatx80 rFm)
270
{
271
  return floatx80_arctan(floatx80_div(rFn,rFm));
272
}
273
#endif