1  | 
     | 
     | 
    //===-- lib/floatsidf.c - integer -> double-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 double-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 DOUBLE_PRECISION  | 
    
    
    17  | 
     | 
     | 
    #include "fp_lib.h"  | 
    
    
    18  | 
     | 
     | 
     | 
    
    
    19  | 
     | 
     | 
    #include "int_lib.h"  | 
    
    
    20  | 
     | 
     | 
     | 
    
    
    21  | 
     | 
     | 
    ARM_EABI_FNALIAS(i2d, floatsidf)  | 
    
    
    22  | 
     | 
     | 
     | 
    
    
    23  | 
     | 
     | 
    COMPILER_RT_ABI fp_t  | 
    
    
    24  | 
     | 
     | 
    __floatsidf(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 and clear the implicit bit.  Extra  | 
    
    
    44  | 
     | 
     | 
        // cast to unsigned int is necessary to get the correct behavior for  | 
    
    
    45  | 
     | 
     | 
        // the input INT_MIN.  | 
    
    
    46  | 
     | 
     | 
        const int shift = significandBits - exponent;  | 
    
    
    47  | 
     | 
     | 
        result = (rep_t)(unsigned int)a << shift ^ implicitBit;  | 
    
    
    48  | 
     | 
     | 
     | 
    
    
    49  | 
     | 
     | 
        // Insert the exponent  | 
    
    
    50  | 
     | 
     | 
        result += (rep_t)(exponent + exponentBias) << significandBits;  | 
    
    
    51  | 
     | 
     | 
        // Insert the sign bit and return  | 
    
    
    52  | 
     | 
     | 
        return fromRep(result | sign);  | 
    
    
    53  | 
     | 
     | 
    }  |