| 1 |  |  | //===-- lib/floatsisf.c - integer -> single-precision conversion --*- C -*-===// | 
    
    | 2 |  |  | // | 
    
    | 3 |  |  | //                     The LLVM Compiler Infrastructure | 
    
    | 4 |  |  | // | 
    
    | 5 |  |  | // This file is dual licensed under the MIT and the University of Illinois Open | 
    
    | 6 |  |  | // Source Licenses. See LICENSE.TXT for details. | 
    
    | 7 |  |  | // | 
    
    | 8 |  |  | //===----------------------------------------------------------------------===// | 
    
    | 9 |  |  | // | 
    
    | 10 |  |  | // This file implements integer to single-precision conversion for the | 
    
    | 11 |  |  | // compiler-rt library in the IEEE-754 default round-to-nearest, ties-to-even | 
    
    | 12 |  |  | // mode. | 
    
    | 13 |  |  | // | 
    
    | 14 |  |  | //===----------------------------------------------------------------------===// | 
    
    | 15 |  |  |  | 
    
    | 16 |  |  | #define SINGLE_PRECISION | 
    
    | 17 |  |  | #include "fp_lib.h" | 
    
    | 18 |  |  |  | 
    
    | 19 |  |  | #include "int_lib.h" | 
    
    | 20 |  |  |  | 
    
    | 21 |  |  | ARM_EABI_FNALIAS(i2f, floatsisf) | 
    
    | 22 |  |  |  | 
    
    | 23 |  |  | COMPILER_RT_ABI fp_t | 
    
    | 24 |  |  | __floatsisf(int a) { | 
    
    | 25 |  |  |  | 
    
    | 26 |  |  |     const int aWidth = sizeof a * CHAR_BIT; | 
    
    | 27 |  |  |  | 
    
    | 28 |  |  |     // Handle zero as a special case to protect clz | 
    
    | 29 |  |  |     if (a == 0) | 
    
    | 30 |  |  |         return fromRep(0); | 
    
    | 31 |  |  |  | 
    
    | 32 |  |  |     // All other cases begin by extracting the sign and absolute value of a | 
    
    | 33 |  |  |     rep_t sign = 0; | 
    
    | 34 |  |  |     if (a < 0) { | 
    
    | 35 |  |  |         sign = signBit; | 
    
    | 36 |  |  |         a = -a; | 
    
    | 37 |  |  |     } | 
    
    | 38 |  |  |  | 
    
    | 39 |  |  |     // Exponent of (fp_t)a is the width of abs(a). | 
    
    | 40 |  |  |     const int exponent = (aWidth - 1) - __builtin_clz(a); | 
    
    | 41 |  |  |     rep_t result; | 
    
    | 42 |  |  |  | 
    
    | 43 |  |  |     // Shift a into the significand field, rounding if it is a right-shift | 
    
    | 44 |  |  |     if (exponent <= significandBits) { | 
    
    | 45 |  |  |         const int shift = significandBits - exponent; | 
    
    | 46 |  |  |         result = (rep_t)a << shift ^ implicitBit; | 
    
    | 47 |  |  |     } else { | 
    
    | 48 |  |  |         const int shift = exponent - significandBits; | 
    
    | 49 |  |  |         result = (rep_t)a >> shift ^ implicitBit; | 
    
    | 50 |  |  |         rep_t round = (rep_t)a << (typeWidth - shift); | 
    
    | 51 |  |  |         if (round > signBit) result++; | 
    
    | 52 |  |  |         if (round == signBit) result += result & 1; | 
    
    | 53 |  |  |     } | 
    
    | 54 |  |  |  | 
    
    | 55 |  |  |     // Insert the exponent | 
    
    | 56 |  |  |     result += (rep_t)(exponent + exponentBias) << significandBits; | 
    
    | 57 |  |  |     // Insert the sign bit and return | 
    
    | 58 |  |  |     return fromRep(result | sign); | 
    
    | 59 |  |  | } |