contrib/llvm-project/compiler-rt/lib/builtins/ppc/fixunstfti.c

   1 //===-- lib/builtins/ppc/fixunstfti.c - Convert long double->int128 *-C -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements converting the 128bit IBM/PowerPC long double (double-
  10 // double) data type to an unsigned 128 bit integer.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "../int_math.h"
  15 #define BIAS 1023
  16
  17 // Convert long double into an unsigned 128-bit integer.
  18 __uint128_t __fixunstfti(long double input) {
  19
  20   // If we are trying to convert a NaN, return the NaN bit pattern.
  21   if (crt_isnan(input)) {
  22     return ((__uint128_t)0x7FF8000000000000ll) << 64 |
  23            (__uint128_t)0x0000000000000000ll;
  24   }
  25
  26   __uint128_t result, hiResult, loResult;
  27   int hiExponent, loExponent, shift;
  28   // The long double representation, with the high and low portions of
  29   // the long double, and the corresponding bit patterns of each double.
  30   union {
  31     long double ld;
  32     double d[2];               // [0] is the high double, [1] is the low double.
  33     unsigned long long ull[2]; // High and low doubles as 64-bit integers.
  34   } ldUnion;
  35
  36   // If the long double is less than 1.0 or negative,
  37   // return 0.0.
  38   if (input < 1.0)
  39     return 0.0;
  40
  41   // Retrieve the 64-bit patterns of high and low doubles.
  42   // Compute the unbiased exponent of both high and low doubles by
  43   // removing the signs, isolating the exponent, and subtracting
  44   // the bias from it.
  45   ldUnion.ld = input;
  46   hiExponent = ((ldUnion.ull[0] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
  47   loExponent = ((ldUnion.ull[1] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
  48
  49   // Convert each double into int64; they will be added to the int128 result.
  50   // CASE 1: High or low double fits in int64
  51   //      - Convert the each double normally into int64.
  52   //
  53   // CASE 2: High or low double does not fit in int64
  54   //      - Scale the double to fit within a 64-bit integer
  55   //      - Calculate the shift (amount to scale the double by in the int128)
  56   //      - Clear all the bits of the exponent (with 0x800FFFFFFFFFFFFF)
  57   //      - Add BIAS+53 (0x4350000000000000) to exponent to correct the value
  58   //      - Scale (move) the double to the correct place in the int128
  59   //        (Move it by 2^53 places)
  60   //
  61   // Note: If the high double is assumed to be positive, an unsigned conversion
  62   // from long double to 64-bit integer is needed. The low double can be either
  63   // positive or negative, so a signed conversion is needed to retain the result
  64   // of the low double and to ensure it does not simply get converted to 0.
  65
  66   // CASE 1 - High double fits in int64.
  67   if (hiExponent < 63) {
  68     hiResult = (unsigned long long)ldUnion.d[0];
  69   } else if (hiExponent < 128) {
  70     // CASE 2 - High double does not fit in int64, scale and convert it.
  71     shift = hiExponent - 54;
  72     ldUnion.ull[0] &= 0x800FFFFFFFFFFFFFll;
  73     ldUnion.ull[0] |= 0x4350000000000000ll;
  74     hiResult = (unsigned long long)ldUnion.d[0];
  75     hiResult <<= shift;
  76   } else {
  77     // Detect cases for overflow. When the exponent of the high
  78     // double is greater than 128 bits and when the long double
  79     // input is positive, return the max 128-bit integer.
  80     // For negative inputs with exponents > 128, return 1, like gcc.
  81     if (ldUnion.d[0] > 0) {
  82       return ((__uint128_t)0xFFFFFFFFFFFFFFFFll) << 64 |
  83              (__uint128_t)0xFFFFFFFFFFFFFFFFll;
  84     } else {
  85       return ((__uint128_t)0x0000000000000000ll) << 64 |
  86              (__uint128_t)0x0000000000000001ll;
  87     }
  88   }
  89
  90   // CASE 1 - Low double fits in int64.
  91   if (loExponent < 63) {
  92     loResult = (long long)ldUnion.d[1];
  93   } else {
  94     // CASE 2 - Low double does not fit in int64, scale and convert it.
  95     shift = loExponent - 54;
  96     ldUnion.ull[1] &= 0x800FFFFFFFFFFFFFll;
  97     ldUnion.ull[1] |= 0x4350000000000000ll;
  98     loResult = (long long)ldUnion.d[1];
  99     loResult <<= shift;
 100   }
 101
 102   // Add the high and low doublewords together to form a 128 bit integer.
 103   result = loResult + hiResult;
 104   return result;
 105 }