reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
//===-- lib/builtins/ppc/fixunstfti.c - Convert long double->int128 *-C -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements converting the 128bit IBM/PowerPC long double (double-
// double) data type to an unsigned 128 bit integer.
//
//===----------------------------------------------------------------------===//

#include "../int_math.h"
#define BIAS 1023

// Convert long double into an unsigned 128-bit integer.
__uint128_t __fixunstfti(long double input) {

  // If we are trying to convert a NaN, return the NaN bit pattern.
  if (crt_isnan(input)) {
    return ((__uint128_t)0x7FF8000000000000ll) << 64 |
           (__uint128_t)0x0000000000000000ll;
  }

  __uint128_t result, hiResult, loResult;
  int hiExponent, loExponent, shift;
  // The long double representation, with the high and low portions of
  // the long double, and the corresponding bit patterns of each double.
  union {
    long double ld;
    double d[2];               // [0] is the high double, [1] is the low double.
    unsigned long long ull[2]; // High and low doubles as 64-bit integers.
  } ldUnion;

  // If the long double is less than 1.0 or negative,
  // return 0.0.
  if (input < 1.0)
    return 0.0;

  // Retrieve the 64-bit patterns of high and low doubles.
  // Compute the unbiased exponent of both high and low doubles by
  // removing the signs, isolating the exponent, and subtracting
  // the bias from it.
  ldUnion.ld = input;
  hiExponent = ((ldUnion.ull[0] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;
  loExponent = ((ldUnion.ull[1] & 0x7FFFFFFFFFFFFFFFll) >> 52) - BIAS;

  // Convert each double into int64; they will be added to the int128 result.
  // CASE 1: High or low double fits in int64
  //      - Convert the each double normally into int64.
  //
  // CASE 2: High or low double does not fit in int64
  //      - Scale the double to fit within a 64-bit integer
  //      - Calculate the shift (amount to scale the double by in the int128)
  //      - Clear all the bits of the exponent (with 0x800FFFFFFFFFFFFF)
  //      - Add BIAS+53 (0x4350000000000000) to exponent to correct the value
  //      - Scale (move) the double to the correct place in the int128
  //        (Move it by 2^53 places)
  //
  // Note: If the high double is assumed to be positive, an unsigned conversion
  // from long double to 64-bit integer is needed. The low double can be either
  // positive or negative, so a signed conversion is needed to retain the result
  // of the low double and to ensure it does not simply get converted to 0.

  // CASE 1 - High double fits in int64.
  if (hiExponent < 63) {
    hiResult = (unsigned long long)ldUnion.d[0];
  } else if (hiExponent < 128) {
    // CASE 2 - High double does not fit in int64, scale and convert it.
    shift = hiExponent - 54;
    ldUnion.ull[0] &= 0x800FFFFFFFFFFFFFll;
    ldUnion.ull[0] |= 0x4350000000000000ll;
    hiResult = (unsigned long long)ldUnion.d[0];
    hiResult <<= shift;
  } else {
    // Detect cases for overflow. When the exponent of the high
    // double is greater than 128 bits and when the long double
    // input is positive, return the max 128-bit integer.
    // For negative inputs with exponents > 128, return 1, like gcc.
    if (ldUnion.d[0] > 0) {
      return ((__uint128_t)0xFFFFFFFFFFFFFFFFll) << 64 |
             (__uint128_t)0xFFFFFFFFFFFFFFFFll;
    } else {
      return ((__uint128_t)0x0000000000000000ll) << 64 |
             (__uint128_t)0x0000000000000001ll;
    }
  }

  // CASE 1 - Low double fits in int64.
  if (loExponent < 63) {
    loResult = (long long)ldUnion.d[1];
  } else {
    // CASE 2 - Low double does not fit in int64, scale and convert it.
    shift = loExponent - 54;
    ldUnion.ull[1] &= 0x800FFFFFFFFFFFFFll;
    ldUnion.ull[1] |= 0x4350000000000000ll;
    loResult = (long long)ldUnion.d[1];
    loResult <<= shift;
  }

  // Add the high and low doublewords together to form a 128 bit integer.
  result = loResult + hiResult;
  return result;
}