← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-arm/nwfpe/single_cpdo.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-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 "fpa11.h"
23
 
#include "softfloat.h"
24
 
#include "fpopcode.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 = float32_zero;
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, &fpa11->fp_status);
80
 
      break;
81
 
 
82
 
      case MUF_CODE:
83
 
      case FML_CODE:
84
 
        fpa11->fpreg[Fd].fSingle = float32_mul(rFn,rFm, &fpa11->fp_status);
85
 
      break;
86
 
 
87
 
      case SUF_CODE:
88
 
         fpa11->fpreg[Fd].fSingle = float32_sub(rFn,rFm, &fpa11->fp_status);
89
 
      break;
90
 
 
91
 
      case RSF_CODE:
92
 
         fpa11->fpreg[Fd].fSingle = float32_sub(rFm,rFn, &fpa11->fp_status);
93
 
      break;
94
 
 
95
 
      case DVF_CODE:
96
 
      case FDV_CODE:
97
 
         fpa11->fpreg[Fd].fSingle = float32_div(rFn,rFm, &fpa11->fp_status);
98
 
      break;
99
 
 
100
 
      case RDF_CODE:
101
 
      case FRD_CODE:
102
 
         fpa11->fpreg[Fd].fSingle = float32_div(rFm,rFn, &fpa11->fp_status);
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, &fpa11->fp_status);
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
 
         fpa11->fpreg[Fd].fSingle = float32_chs(rFm);
132
 
      break;
133
 
 
134
 
      case ABS_CODE:
135
 
         fpa11->fpreg[Fd].fSingle = float32_abs(rFm);
136
 
      break;
137
 
 
138
 
      case RND_CODE:
139
 
      case URD_CODE:
140
 
         fpa11->fpreg[Fd].fSingle = float32_round_to_int(rFm, &fpa11->fp_status);
141
 
      break;
142
 
 
143
 
      case SQT_CODE:
144
 
         fpa11->fpreg[Fd].fSingle = float32_sqrt(rFm, &fpa11->fp_status);
145
 
      break;
146
 
 
147
 
#if 0
148
 
      case LOG_CODE:
149
 
         fpa11->fpreg[Fd].fSingle = float32_log(rFm);
150
 
      break;
151
 
 
152
 
      case LGN_CODE:
153
 
         fpa11->fpreg[Fd].fSingle = float32_ln(rFm);
154
 
      break;
155
 
 
156
 
      case EXP_CODE:
157
 
         fpa11->fpreg[Fd].fSingle = float32_exp(rFm);
158
 
      break;
159
 
 
160
 
      case SIN_CODE:
161
 
         fpa11->fpreg[Fd].fSingle = float32_sin(rFm);
162
 
      break;
163
 
 
164
 
      case COS_CODE:
165
 
         fpa11->fpreg[Fd].fSingle = float32_cos(rFm);
166
 
      break;
167
 
 
168
 
      case TAN_CODE:
169
 
         fpa11->fpreg[Fd].fSingle = float32_tan(rFm);
170
 
      break;
171
 
 
172
 
      case ASN_CODE:
173
 
         fpa11->fpreg[Fd].fSingle = float32_arcsin(rFm);
174
 
      break;
175
 
 
176
 
      case ACS_CODE:
177
 
         fpa11->fpreg[Fd].fSingle = float32_arccos(rFm);
178
 
      break;
179
 
 
180
 
      case ATN_CODE:
181
 
         fpa11->fpreg[Fd].fSingle = float32_arctan(rFm);
182
 
      break;
183
 
#endif
184
 
 
185
 
      case NRM_CODE:
186
 
      break;
187
 
 
188
 
      default:
189
 
      {
190
 
        nRc = 0;
191
 
      }
192
 
   }
193
 
 
194
 
   if (0 != nRc) fpa11->fType[Fd] = typeSingle;
195
 
   return nRc;
196
 
}
197
 
 
198
 
#if 0
199
 
float32 float32_exp(float32 Fm)
200
 
{
201
 
//series
202
 
}
203
 
 
204
 
float32 float32_ln(float32 Fm)
205
 
{
206
 
//series
207
 
}
208
 
 
209
 
float32 float32_sin(float32 rFm)
210
 
{
211
 
//series
212
 
}
213
 
 
214
 
float32 float32_cos(float32 rFm)
215
 
{
216
 
//series
217
 
}
218
 
 
219
 
float32 float32_arcsin(float32 rFm)
220
 
{
221
 
//series
222
 
}
223
 
 
224
 
float32 float32_arctan(float32 rFm)
225
 
{
226
 
  //series
227
 
}
228
 
 
229
 
float32 float32_arccos(float32 rFm)
230
 
{
231
 
   //return float32_sub(halfPi,float32_arcsin(rFm));
232
 
}
233
 
 
234
 
float32 float32_log(float32 rFm)
235
 
{
236
 
  return float32_div(float32_ln(rFm),getSingleConstant(7));
237
 
}
238
 
 
239
 
float32 float32_tan(float32 rFm)
240
 
{
241
 
  return float32_div(float32_sin(rFm),float32_cos(rFm));
242
 
}
243
 
 
244
 
float32 float32_pow(float32 rFn,float32 rFm)
245
 
{
246
 
  return float32_exp(float32_mul(rFm,float32_ln(rFn)));
247
 
}
248
 
 
249
 
float32 float32_pol(float32 rFn,float32 rFm)
250
 
{
251
 
  return float32_arctan(float32_div(rFn,rFm));
252
 
}
253
 
#endif