Subversion Repositories HelenOS-historic

Rev

Rev 734 | Rev 804 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
535 cejka 1
/*
2
 * Copyright (C) 2005 Josef Cejka
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
#include<softfloat.h>
647 cejka 30
#include<sftypes.h>
731 cejka 31
 
32
#include<add.h>
33
#include<sub.h>
34
#include<mul.h>
35
#include<div.h>
36
 
647 cejka 37
#include<conversion.h>
38
#include<comparison.h>
39
#include<other.h>
535 cejka 40
 
647 cejka 41
/* Arithmetic functions */
542 cejka 42
 
43
float __addsf3(float a, float b)
44
{
45
    float32 fa, fb;
563 cejka 46
    fa.f=a;
47
    fb.f=b;
647 cejka 48
    if (fa.parts.sign!=fb.parts.sign) {
49
        if (fa.parts.sign) {
50
            fa.parts.sign=0;
51
            return subFloat32(fb,fa).f;
52
        };
53
        fb.parts.sign=0;
54
        return subFloat32(fa,fb).f;
55
    }
563 cejka 56
    return addFloat32(fa,fb).f;
698 cejka 57
}
542 cejka 58
 
734 cejka 59
double __adddf3(double a, double b)
60
{
61
    float64 da, db;
62
    da.d=a;
63
    db.d=b;
64
    if (da.parts.sign!=db.parts.sign) {
65
        if (da.parts.sign) {
66
            da.parts.sign=0;
67
            return subFloat64(db,da).d;
68
        };
69
        db.parts.sign=0;
70
        return subFloat64(da,db).d;
71
    }
72
    return addFloat64(da,db).d;
73
}
74
 
542 cejka 75
float __subsf3(float a, float b)
76
{
77
    float32 fa, fb;
563 cejka 78
    fa.f=a;
79
    fb.f=b;
647 cejka 80
    if (fa.parts.sign!=fb.parts.sign) {
660 cejka 81
        fb.parts.sign=!fb.parts.sign;
647 cejka 82
        return addFloat32(fa,fb).f;
83
    }
563 cejka 84
    return subFloat32(fa,fb).f;
698 cejka 85
}
542 cejka 86
 
734 cejka 87
double __subdf3(double a, double b)
88
{
89
    float64 da, db;
90
    da.d = a;
91
    db.d = b;
92
    if (da.parts.sign != db.parts.sign) {
93
        db.parts.sign = !db.parts.sign;
94
        return addFloat64(da, db).d;
95
    }
96
    return subFloat64(da, db).d;
97
}
98
 
688 cejka 99
float __mulsf3(float a, float b)
100
{
101
    float32 fa, fb;
102
    fa.f=a;
103
    fb.f=b;
104
    return  mulFloat32(fa, fb).f;
105
}
106
 
737 cejka 107
double __muldf3(double a, double b)
108
{
109
    float64 da, db;
110
    da.d = a;
111
    db.d = b;
112
    return  mulFloat64(da, db).d;
113
}
114
 
697 cejka 115
float __divsf3(float a, float b)
116
{
117
    float32 fa, fb;
118
    fa.f=a;
119
    fb.f=b;
731 cejka 120
    //return    divFloat32(fa, fb).f;
698 cejka 121
}
697 cejka 122
 
542 cejka 123
float __negsf2(float a)
124
{
125
    float32 fa;
126
    fa.f=a;
127
    fa.parts.sign=!fa.parts.sign;
128
    return fa.f;
698 cejka 129
}
542 cejka 130
 
131
double __negdf2(double a)
132
{
133
    float64 fa;
563 cejka 134
    fa.d=a;
542 cejka 135
    fa.parts.sign=!fa.parts.sign;
563 cejka 136
    return fa.d;
698 cejka 137
}
542 cejka 138
 
647 cejka 139
/* Conversion functions */
542 cejka 140
 
697 cejka 141
double __extendsfdf2(float a)
142
{
143
    float32 fa;
144
    fa.f = a;
145
    return convertFloat32ToFloat64(fa).d;
698 cejka 146
}
697 cejka 147
 
148
float __truncdfsf2(double a)
149
{
150
    float64 da;
151
    da.d = a;
152
    return convertFloat64ToFloat32(da).f;
153
}
698 cejka 154
 
647 cejka 155
/* Comparison functions */
542 cejka 156
 
652 cejka 157
/* a<b .. -1
158
 * a=b ..  0
159
 * a>b ..  1
160
 * */
161
 
660 cejka 162
int __cmpsf2(float a, float b)
652 cejka 163
{
164
    float32 fa,fb;
165
    fa.f=a;
166
    fb.f=b;
167
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
168
        return 1; /* no special constant for unordered - maybe signaled? */
169
    };
170
 
171
 
172
    if (isFloat32eq(fa,fb)) {
173
        return 0;
174
    };
175
 
176
    if (isFloat32lt(fa,fb)) {
177
        return -1;
178
        };
179
    return 1;
180
}
181
 
182
int __unordsf2(float a, float b)
183
{
184
    float32 fa,fb;
185
    fa.f=a;
186
    fb.f=b;
187
    return ((isFloat32NaN(fa))||(isFloat32NaN(fb)));
698 cejka 188
}
652 cejka 189
 
190
/**
191
 * @return zero, if neither argument is a NaN and are equal
192
 * */
193
int __eqsf2(float a, float b)
194
{
195
    float32 fa,fb;
196
    fa.f=a;
197
    fb.f=b;
198
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
199
        /* TODO: sigNaNs*/
200
        return 1;
201
        };
202
    return isFloat32eq(fa,fb)-1;
698 cejka 203
}
652 cejka 204
 
205
/* strange behavior, but it was in gcc documentation */
206
int __nesf2(float a, float b)
207
{
208
    return __eqsf2(a,b);
698 cejka 209
}
653 cejka 210
 
211
/* return value >= 0 if a>=b and neither is NaN */
212
int __gesf2(float a, float b)
213
{
214
    float32 fa,fb;
215
    fa.f=a;
216
    fb.f=b;
217
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
218
        /* TODO: sigNaNs*/
660 cejka 219
        return -1;
653 cejka 220
        };
221
 
222
    if (isFloat32eq(fa,fb)) {
223
        return 0;
224
    };
225
 
226
    if (isFloat32gt(fa,fb)) {
227
        return 1;
228
        };
229
 
230
    return -1;
231
}
232
 
233
/** Return negative value, if a<b and neither is NaN*/
234
int __ltsf2(float a, float b)
235
{
236
    float32 fa,fb;
237
    fa.f=a;
238
    fb.f=b;
239
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
240
        /* TODO: sigNaNs*/
241
        return 1;
242
        };
243
    if (isFloat32lt(fa, fb)) {
244
        return -1;
245
        };
246
    return 0;
247
}
248
 
249
/* return value <= 0 if a<=b and neither is NaN */
250
int __lesf2(float a, float b)
251
{
252
    float32 fa,fb;
253
    fa.f=a;
254
    fb.f=b;
255
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
256
        /* TODO: sigNaNs*/
257
        return 1;
258
        };
259
 
260
    if (isFloat32eq(fa,fb)) {
261
        return 0;
262
    };
263
 
264
    if (isFloat32lt(fa,fb)) {
265
        return -1;
266
        };
267
 
268
    return 1;
269
}
270
 
271
/** Return positive value, if a>b and neither is NaN*/
660 cejka 272
int __gtsf2(float a, float b)
653 cejka 273
{
274
    float32 fa,fb;
275
    fa.f=a;
276
    fb.f=b;
277
    if ((isFloat32NaN(fa))||(isFloat32NaN(fb))) {
278
        /* TODO: sigNaNs*/
660 cejka 279
        return -1;
653 cejka 280
        };
281
    if (isFloat32gt(fa, fb)) {
282
        return 1;
283
        };
284
    return 0;
285
}
286
 
647 cejka 287
/* Other functions */
542 cejka 288
 
698 cejka 289
float __powisf2(float a, int b)
290
{
291
//TODO: 
292
}
293
 
294
float __mulsc3(float a, float b, float c, float d)
295
{
296
//TODO:
297
}
298
 
299
float __divsc3(float a, float b, float c, float d)
300
{
301
//TODO:
302
}
303