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