Subversion Repositories HelenOS-historic

Rev

Rev 835 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 835 Rev 1031
Line 35... Line 35...
35
 
35
 
36
 
36
 
37
float32 divFloat32(float32 a, float32 b)
37
float32 divFloat32(float32 a, float32 b)
38
{
38
{
39
    float32 result;
39
    float32 result;
40
    __s32 aexp, bexp, cexp;
40
    int32_t aexp, bexp, cexp;
41
    __u64 afrac, bfrac, cfrac;
41
    uint64_t afrac, bfrac, cfrac;
42
   
42
   
43
    result.parts.sign = a.parts.sign ^ b.parts.sign;
43
    result.parts.sign = a.parts.sign ^ b.parts.sign;
44
   
44
   
45
    if (isFloat32NaN(a)) {
45
    if (isFloat32NaN(a)) {
46
        if (isFloat32SigNaN(a)) {
46
        if (isFloat32SigNaN(a)) {
Line 178... Line 178...
178
            cexp ++;
178
            cexp ++;
179
            cfrac >>= 1;
179
            cfrac >>= 1;
180
        }
180
        }
181
       
181
       
182
    } else {
182
    } else {
183
        result.parts.exp = (__u32)cexp;
183
        result.parts.exp = (uint32_t)cexp;
184
    }
184
    }
185
   
185
   
186
    result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
186
    result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
187
   
187
   
188
    return result; 
188
    return result; 
189
}
189
}
190
 
190
 
191
float64 divFloat64(float64 a, float64 b)
191
float64 divFloat64(float64 a, float64 b)
192
{
192
{
193
    float64 result;
193
    float64 result;
194
    __s64 aexp, bexp, cexp;
194
    int64_t aexp, bexp, cexp;
195
    __u64 afrac, bfrac, cfrac;
195
    uint64_t afrac, bfrac, cfrac;
196
    __u64 remlo, remhi;
196
    uint64_t remlo, remhi;
197
   
197
   
198
    result.parts.sign = a.parts.sign ^ b.parts.sign;
198
    result.parts.sign = a.parts.sign ^ b.parts.sign;
199
   
199
   
200
    if (isFloat64NaN(a)) {
200
    if (isFloat64NaN(a)) {
201
       
201
       
Line 304... Line 304...
304
        mul64integers( bfrac, cfrac, &remlo, &remhi);
304
        mul64integers( bfrac, cfrac, &remlo, &remhi);
305
        /* (__u128)afrac << 64 - ( ((__u128)remhi<<64) + (__u128)remlo )*/ 
305
        /* (__u128)afrac << 64 - ( ((__u128)remhi<<64) + (__u128)remlo )*/ 
306
        remhi = afrac - remhi - ( remlo > 0);
306
        remhi = afrac - remhi - ( remlo > 0);
307
        remlo = - remlo;
307
        remlo = - remlo;
308
       
308
       
309
        while ((__s64) remhi < 0) {
309
        while ((int64_t) remhi < 0) {
310
            cfrac--;
310
            cfrac--;
311
            remlo += bfrac;
311
            remlo += bfrac;
312
            remhi += ( remlo < bfrac );
312
            remhi += ( remlo < bfrac );
313
        }
313
        }
314
        cfrac |= ( remlo != 0 );
314
        cfrac |= ( remlo != 0 );
Line 318... Line 318...
318
    result = finishFloat64(cexp, cfrac, result.parts.sign);
318
    result = finishFloat64(cexp, cfrac, result.parts.sign);
319
    return result;
319
    return result;
320
 
320
 
321
}
321
}
322
 
322
 
323
__u64 divFloat64estim(__u64 a, __u64 b)
323
uint64_t divFloat64estim(uint64_t a, uint64_t b)
324
{
324
{
325
    __u64 bhi;
325
    uint64_t bhi;
326
    __u64 remhi, remlo;
326
    uint64_t remhi, remlo;
327
    __u64 result;
327
    uint64_t result;
328
   
328
   
329
    if ( b <= a ) {
329
    if ( b <= a ) {
330
        return 0xFFFFFFFFFFFFFFFFull;
330
        return 0xFFFFFFFFFFFFFFFFull;
331
    }
331
    }
332
   
332
   
Line 336... Line 336...
336
   
336
   
337
    remhi = a - remhi - (remlo > 0);
337
    remhi = a - remhi - (remlo > 0);
338
    remlo = - remlo;
338
    remlo = - remlo;
339
 
339
 
340
    b <<= 32;
340
    b <<= 32;
341
    while ( (__s64) remhi < 0 ) {
341
    while ( (int64_t) remhi < 0 ) {
342
            result -= 0x1ll << 32; 
342
            result -= 0x1ll << 32; 
343
            remlo += b;
343
            remlo += b;
344
            remhi += bhi + ( remlo < b );
344
            remhi += bhi + ( remlo < b );
345
        }
345
        }
346
    remhi = (remhi << 32) | (remlo >> 32);
346
    remhi = (remhi << 32) | (remlo >> 32);