[compiler-rt][builtins][PowerPC] Add floattitf builtin compiler-rt method support for PowerPC

[amyk]

Summary

This patch implements the long double floattitf (int128_t) method for PowerPC — specifically to convert a 128 bit integer into a long double (IBM double-double).

The algorithm used in this conversion method from int128_t to long double utilizes the long double floatditf (int64_t) and long double floatunditf (uint64_t) methods, which are already implemented under lib/builtins/ppc/.

This method can be invoked by linking against compiler-rt instead of libgcc, via the -rtlib=compiler-rt command line option supplied to clang.

[renenkel]

The summary doesn't match the code. The code floattitf.c converts from 128-bit int to long double, but the summary says it goes the opposite direction.

[amyk]

@renenkel Yes, thank you for pointing that out. I accidentally mixed that up, my apologies. The summary has been corrected to reflect the correct behaviour.

[nemanjai]

I'll let @renenkel approve or request changes to this as he understands the math much better than I do, but I do want an investigation into how the INFINITY/QNAN tests work along with a comment explaining that. Particularly since I would have expected that every __int128_t value is a number (i.e. not a NAN) and none of them produce an infinity.

compiler-rt/lib/builtins/ppc/floattitf.c

21

Just out of curiosity, where does __int128_t come from if we don't include a header that defines it? Does this compile with both gcc and clang?

compiler-rt/test/builtins/Unit/ppc/floattitf_test.h

16

I find it really strange that this works. What is __builtin_inf() converted to __int128_t? Similarly with __builtin_nan().

[renenkel]

I think the use of the DD.h include file makes the code confusing, for several reasons: 1. It requires you to look at two files; 2. An additional assignment is required to interpret the component doubles of the long double as 64-bit ints. I suggest you retain the original form of the union, for example:

#define HI 0
#define LO 1
// Use enum HILO {HI=0, LO=1}; if LLVM style discourages #define

union {long double ld; double d[2]; uint64_t ui[2];} uld;

uld.ld = ld;
// Now you can access any of them easily...
uld.d[HI]
uld.d[LO]
uld.ui[HI]
uld.ui{LO]

[renenkel]

Regarding Nemanjai's comment, "I would have expected that every __int128_t value is a number (i.e. not a NAN) and none of them produce an infinity." Correct. No 128-bit int converted to a long double should produce NaN or Inf. However, we have to decide what should happen when a long double NaN or Inf gets converted to a 128-bit int. It seems reasonable that +-Inf gets converted to the largest/smallest int128 of the same sign. But there is not really any natural value for NaN. Unless there is a standard governing this, I would suggest it should be undefined. We've chosen to retain the same bit pattern of the long double NaN in the converted int128. The gcc conversion produces a strange arbitrary number 0x80...080...080...080...0. I'm not sure what the value would be in matching this, but it would be possible with a special case, should that be deemed necessary.

[renenkel]

Masoud wrote a test program that exercises the conversions over the full range of exponents and compares the results to the gcc conversion. My understanding is that the results matched except for the long double NaN (which is arbitrary), and some long doubles with gaps between the high and low double, for which it was possible to determine that the gcc result was wrong (Masoud, please confirm?)

[renenkel]

This comment has been deleted.

compiler-rt/test/builtins/Unit/ppc/floattitf_test.h

16

Do I understand correctly that testCase.input128 is the 128-bit int input to the conversion, and testCase.hi and lo are the hi and lo doubles of the long double that should be produced by the conversion?

In this case, as Nemanjai points out, INFINITY and QNAN don't make sense as inputs to the int128->long double conversion. Those four lines should be removed (in which case the corresponding #defines aren't needed and can be removed too).

[amyk]

compiler-rt/lib/builtins/ppc/floattitf.c

21

The __int128_t and __uint128_t types are defined within gcc (cc1), not in a header I believe. They are available in both gcc and clang. There does not seem to be anything in the gcc documentation regarding these types, but they seem equivalent to __int128 and unsigned __int128 (https://gcc.gnu.org/ml/libstdc++/2011-09/msg00068.html).

I would have used __int128 and unsigned __int128, however compiling with them gave me warnings in LLVM saying that they were unsupported.

compiler-rt/test/builtins/Unit/ppc/floattitf_test.h

16

Yeah, that is true. I originally added these since I based my tests off of existing compiler-rt PPC builtins tests, and they included testing for inf/nan in this manner. I went back to see the high and low parts of both of those functions and they did not really correspond to the values of infinity and NaN that Masoud/Robert previously talked about in our conversations. As per Robert's suggestion, I will remove these since they do not really make sense to include.

16

Yes, you are correct. I will remove them as I see they don't quite make sense as inputs for the conversion.

[amyk]

Updated this patch to reflect:

• Changed variable names;
• Removed test cases with INFINITY and NAN
• Added the long double union structure (containing high and low double portions, and their corresponding bit patterns) to be used in the testing file (to remove the dependency of looking at two files for the implementation of the long double)

[renenkel]

compiler-rt/lib/builtins/ppc/floattitf.c

21

"This file implements converting an unsigned 128 bit integer to a 128bit IBM/PowerPC long double (double-double) value." No, this is the signed conversion.

What's in DD.h? Is it needed? If not, remove it.

The variable hiPart. HIgh part of what? How about arg_hiPart?

The variables hiDouble and loDouble. These names are misleading. They're not doubles. They're arg_hiPart and arg_loPart converted to long double. How about LD_arg_loPart and LD_arg_hiPart?

The choice of name of the constant eachDWordSize is misleading, as is the comment, "The size of each high and low part of the 128 bit integer." It's not a word size but rather two the power of 64, the value you multiply by to shift by the word size. A better name would be simply two64. However, why initialize a double constant with this value, when in the next line you cast it into a long double?

Here is what I think the code should look like. (After changing it, to be safe, you should run Masoud's full-range test harness again.)

//===-- lib/builtins/ppc/floattitf.c - Convert int128->long double -*-C -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements conversion of a signed 128 bit integer to a 128bit IBM/
// PowerPC long double (double-double) value.
//
//===----------------------------------------------------------------------===//

/* Conversions from signed and unsigned 64-bit int to long double */
long double __floatditf (int64_t);
long double __floatunditf (uint64_t);

/* Convert signed 128-bit int to long double.  This uses the following
 * property:  Let hi and lo be 64-bits each, and let signed_val_k() and
 * unsigned_val_k()be the value of the argument interpreted as a signed
 * or unsigned k-bit integer, respectively.  Then,
 * signed_val_128(hi,lo) = signed_val_64(hi) * 2^64 + unsigned_val_64(lo)
 * = (long double)hi * 2^64 + (long double)lo,
 * where (long double)hi and (long double)lo are signed and
 * unsigned 64-bit int to long double conversions, respectively.
*/

long double __floattitf (__int128_t arg) {
  /* Split the int128 argument into high and low 64-bit parts. */
  int64_t arg_hiPart = (int64_t)(arg >> 64);
  int64_t arg_loPart = (int64_t) arg;

  /* Convert each 64-bit part into long double. The high part
   * must be a signed conversion and the low part an unsigned
   * conversion to produce the correct result. */
  long double LD_arg_hiPart = __floatditf(arg_hiPart);
  long double LD_arg_loPart = __floatunditf(arg_loPart);

  /* The low bit of arg_hiPart corresponds to the 2^64 bit in arg.
   * Multiply the high part by 2^64 to undo the right shift by
   * 64-bits done in the splitting, and add to the low part to
   * obtain the final result.
  static const double two64 = 0x1.0p64;  // 2^64
  return (LD_arg_hiPart * two64 + LD_arg_loPart);
}

[renenkel]

In floattitf_test.c,

typedef union {
  long double ld;
  double doublePairs[2]; /* [0] is the high double, [1] is the low double. */
  unsigned long long doubleBitPatterns[2];
} ldStructure;

is confusing. Clearer would be:

typedef 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 ints */
} ldStructure;

is con

[amyk]

Updated patch to address @renenkel's review :

• Renamed union type to represent the long double
• Updated comments
• Updated variable names
• Updated algorithm to be more concise and succinct

This revision has been tested using Masoud's test harness. There are no changes or errors uncovered in the test harness with this updated revision.

[amyk]

Updated this patch with:

• initialization of int128 macro to simplify test cases

[nemanjai]

The remaining comments from me are minor. I am OK with this going in if Robert is.

compiler-rt/lib/builtins/ppc/floattitf.c

36

uint64_t vs int64_t?
ArgLoPart?

42

I am not sure if any compiler would emit warnings in pedantic mode for a signed argument being passed to a function that takes an unsigned parameter. But I also don't see a compelling need to have both of these signed. The algorithm described states that the low part is treated as unsigned. Why not just declare it as uint64_t as well?

Also, I know that there isn't as much adherence to general LLVM naming conventions in compiler-rt currently, but I don't see why we wouldn't adhere to them on new code.
Seems that these should be along the lines of ConvertedHiPart, etc.

48

I don't think we should add this temporary.

[amyk]

compiler-rt/lib/builtins/ppc/floattitf.c

42

Yeah. that is a good point. I will change the low part to unsigned, and also rename the variables a little to adhere to LLVM naming conventions.

48

I will remove it.

[amyk]

Updated patch to address:

• renamed variables for names that adhere more to LLVM naming conventions
• changed the low part of the function argument to unsigned, as it will later be passed into a function that expects an unsigned argument
• Removed a temporary that represented 2^64.

[renenkel]

I'm okay with the style of the code now. Did you run Masoud's test program after making your changes? If not, you need to do that.

[renenkel]

Amy ran Masoud's tests, so I approve.

[nemanjai]

Amy, can we get this committed?

[amyk]

In D54313#1356885, @nemanjai wrote:

Amy, can we get this committed?

I didn't realize this, but I have already committed this builtin along with __fixunsuftsti recently, however I am not sure why this revision is not closed. The other one was closed when I committed it and supplied the revision number, but for some reason, this one was not closed. I will close this now as this was been committed.

compiler-rt/lib/builtins/CMakeLists.txt

set(mips64_SOURCES ${GENERIC_TF_SOURCES}
                    ${mips_SOURCES})
 set(mips64el_SOURCES ${GENERIC_TF_SOURCES}
                      ${mips_SOURCES})
 
 set(powerpc64_SOURCES
   ppc/divtc3.c
   ppc/fixtfdi.c
   ppc/fixunstfdi.c
+  ppc/floattitf.c
   ppc/floatditf.c
   ppc/floatunditf.c
   ppc/gcc_qadd.c
   ppc/gcc_qdiv.c
   ppc/gcc_qmul.c
   ppc/gcc_qsub.c
   ppc/multc3.c
   ${GENERIC_SOURCES})

compiler-rt/lib/builtins/ppc/floattitf.c

+//===-- lib/builtins/ppc/floattitf.c - Convert int128->long double -*-C -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements converting an unsigned 128 bit integer to a 128bit IBM/
+// PowerPC long double (double-double) value.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DD.h"
+
+/* Conversions to be used for high and low parts of long double. */
+long double __floatditf (int64_t);
+long double __floatunditf (uint64_t);
+
+long double __floattitf (__int128_t arg) {
+  /* 128 bit integers can be thought of as having a high and a low
+   * portion, each high and low portion consisting of 64 bits each.
+   * Split the int128 into their respective high and low parts. */
+  int64_t hi_part = (int64_t)(arg >> 64);
+  int64_t lo_part = (int64_t) arg;
+
+  /* Convert each 64-bit part into double-double. The high part
+   * must be a signed conversion to ensure the correct result. */
+  long double hi_double = __floatditf(hi_part);
+  long double lo_double = __floatunditf(lo_part);
+
+  /* The size of each high and low part of the 128 bit integer.
+   * Each 128 bit integer is constructed from two doublewords.
+   * This is used to ensure we have the correct high portion. */
+  static const double eachDWordSize = 0x1.0p64;
+
+  /* Multiply the high part of the long double by 2^64 to undo
+   * the splitting of the high and low parts of the 128bit integer. */
+  long double new_hi = hi_double * ((long double) eachDWordSize);
+
+  /* Add the high and low parts together to obtain
+   * the long double result. */
+  return (new_hi + lo_double);
+}

compiler-rt/test/builtins/Unit/ppc/floattitf_test.h

+/*
+* Test case inputs for: long double __floattitf (__int128_t)
+* Conversion from 128 bit integer to long double (IBM double-double).
+*/
+
+#define INFINITY __builtin_inf()
+#define QNAN __builtin_nan("")
+
+struct testCase {
+  __int128_t input128;
+  double hi;
+  double lo;
+};
+
+struct testCase tests[] = {
+{ INFINITY, 0x1p+127, -0x1p+0 },
+{ -INFINITY, -0x1p+127, 0x0p+0 },
+{ QNAN, 0x0p+0, 0x0p+0 },
+{ -QNAN, 0x0p+0, 0x0p+0 },
+{ (__int128_t) -0, 0x0p+0, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000000, 0x0p+0, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000001, 0x1p+0 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x1000000000000000, 0x1p+60 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xffffffffffffffff, 0x1p+64 , -0x1p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x7fffffffffffffff, 0x1p+63 , -0x1p+0 },
+{ ((__int128_t)0x0000000000000001 << 64) | 0x0000000000000000, 0x1p+64 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000001 << 64) | 0x0000000000000001, 0x1p+64 , 0x1p+0 },
+{ ((__int128_t)0x0000000000000001 << 64) | 0x7fffffffffffffff, 0x1.8p+64 , -0x1p+0 },
+{ ((__int128_t)0x0000000000000001 << 64) | 0x1000000000000000, 0x1.1p+64 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000001 << 64) | 0xffffffffffffffff, 0x1p+65 , -0x1p+0 },
+{ ((__int128_t)0x7fffffffffffffff << 64) | 0x0000000000000000, 0x1p+127 , -0x1p+64 },
+{ ((__int128_t)0x7fffffffffffffff << 64) | 0x0000000000000001, 0x1p+127 , -0x1p+64 },
+{ ((__int128_t)0x7fffffffffffffff << 64) | 0x7fffffffffffffff, 0x1p+127 , -0x1p+63 },
+{ ((__int128_t)0x7fffffffffffffff << 64) | 0x1000000000000000, 0x1p+127 , -0x1.ep+63 },
+{ ((__int128_t)0x7fffffffffffffff << 64) | 0xffffffffffffffff, 0x1p+127 , -0x1p+0 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000000000, 0x1p+124 , 0x0p+0 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000000001, 0x1p+124 , 0x1p+0 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x7fffffffffffffff, 0x1p+124 , 0x1p+63 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x1000000000000000, 0x1p+124 , 0x1p+60 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0xffffffffffffffff, 0x1p+124 , 0x1p+64 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0x0000000000000000, -0x1p+64 , 0x0p+0 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0x0000000000000001, -0x1p+64 , 0x1p+0 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0x7fffffffffffffff, -0x1p+63 , -0x1p+0 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0x1000000000000000, -0x1.ep+63 , 0x0p+0 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0xffffffffffffffff, -0x1p+0 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000061 << 64) | 0x0000000000000061, 0x1.84p+70, 0x1.84p+6 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000057, 0x1.5cp+6, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xffffffffffffff9e, 0x1p+64 , -0x1.88p+6 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000062, 0x1.88p+6, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000403, 0x1.00cp+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffffffffffffbfc, 0x1.fffffffffffffp+63 , 0x1.fep+9 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x000000000000040a, 0x1.028p+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x000000000000040c, 0x1.03p+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x000000000000041a, 0x1.068p+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000510, 0x1.44p+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000518, 0x1.46p+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffffffffffffae7, 0x1.fffffffffffffp+63 , 0x1.738p+9 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000000602, 0x1.808p+10, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffffffffffff9fd, 0x1.fffffffffffffp+63 , 0x1.fdp+8 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000002090, 0x1.048p+13, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xffffffffffffdbdb, 0x1.ffffffffffffbp+63 , 0x1.ed8p+9 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000002430, 0x1.218p+13, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000020202, 0x1.0101p+17, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffffffffffdeef7, 0x1.fffffffffffbep+63 , -0x1.09p+8 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000032004, 0x1.9002p+17, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffffffffffcdffb, 0x1.fffffffffff9cp+63 , -0x1.4p+2 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000032040, 0x1.902p+17, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xffffffffffbfdfbb, 0x1.ffffffffff7fcp+63 , -0x1.14p+6 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000000402088, 0x1.00822p+22, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000080080088, 0x1.0010011p+31, 0x0p+0 },
+{ ((__int128_t)0xffffffff7ff7ff77 << 64) | 0xffffffff7ff7ff77, -0x1.0010011p+95 , -0x1.00100112p+31 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000000850000008, 0x1.0a000001p+35, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000002000000448, 0x1.000000224p+37, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xffffffdfff7dbfff, 0x1.ffffffbffefb8p+63 , -0x1p+0 },
+{ ((__int128_t)0x0000004002001100 << 64) | 0x0000004002001100, 0x1.00080044p+102 , 0x1.00080044p+38 },
+{ ((__int128_t)0x000008020000000c << 64) | 0x000008020000000c, 0x1.00400000018p+107 , 0x1.00400000018p+43 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffff7fdfffffff3, 0x1.ffffeffcp+63 , -0x1.ap+3 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x0000800000000824, 0x1.000000001048p+47, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffdffffff7ffcff, 0x1.fffbffffffp+63 , -0x1.808p+9 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x4002040010000000, 0x1.000810004p+62, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xbffdfbffefffffff, 0x1.7ffbf7ffep+63 , -0x1p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x8000000000000000, 0x1p+63, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xfffffffff418c5c1, 0x1.ffffffffe8319p+63 , -0x1.1f8p+9 },
+{ ((__int128_t)0x000000000000000f << 64) | 0xffffffffffffffff, 0x1p+68 , -0x1p+0 },
+{ ((__int128_t)0x00000000000000ff << 64) | 0xffffffffffffffff, 0x1p+72 , -0x1p+0 },
+{ ((__int128_t)0x0000000000000fff << 64) | 0xffffffffffffffff, 0x1p+76 , -0x1p+0 },
+{ ((__int128_t)0x000000000000ffff << 64) | 0xffffffffffffffff, 0x1p+80 , -0x1p+0 },
+{ ((__int128_t)0x00000000000fffff << 64) | 0xffffffffffffffff, 0x1p+84 , -0x1p+0 },
+{ ((__int128_t)0x0000000000ffffff << 64) | 0xffffffffffffffff, 0x1p+88 , -0x1p+0 },
+{ ((__int128_t)0x000000000fffffff << 64) | 0xffffffffffffffff, 0x1p+92 , -0x1p+0 },
+{ ((__int128_t)0x00000000ffffffff << 64) | 0xffffffffffffffff, 0x1p+96 , -0x1p+0 },
+{ ((__int128_t)0x0000000fffffffff << 64) | 0xffffffffffffffff, 0x1p+100 , -0x1p+0 },
+{ ((__int128_t)0x000000ffffffffff << 64) | 0xffffffffffffffff, 0x1p+104 , -0x1p+0 },
+{ ((__int128_t)0x00000fffffffffff << 64) | 0xffffffffffffffff, 0x1p+108 , -0x1p+0 },
+{ ((__int128_t)0x0000ffffffffffff << 64) | 0xffffffffffffffff, 0x1p+112 , -0x1p+0 },
+{ ((__int128_t)0x000fffffffffffff << 64) | 0xffffffffffffffff, 0x1p+116 , -0x1p+0 },
+{ ((__int128_t)0x00ffffffffffffff << 64) | 0xffffffffffffffff, 0x1p+120 , -0x1p+0 },
+{ ((__int128_t)0x0fffffffffffffff << 64) | 0xffffffffffffffff, 0x1p+124 , -0x1p+0 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000000000, 0x1p+124 , 0x0p+0 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000000011, 0x1p+124 , 0x1.1p+4 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000000111, 0x1p+124 , 0x1.11p+8 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000001111, 0x1p+124 , 0x1.111p+12 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000011111, 0x1p+124 , 0x1.1111p+16 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000000111111, 0x1p+124 , 0x1.11111p+20 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000001111111, 0x1p+124 , 0x1.111111p+24 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000011111111, 0x1p+124 , 0x1.1111111p+28 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000000111111111, 0x1p+124 , 0x1.11111111p+32 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000001111111111, 0x1p+124 , 0x1.111111111p+36 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000011111111111, 0x1p+124 , 0x1.1111111111p+40 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0000111111111111, 0x1p+124 , 0x1.11111111111p+44 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0001111111111111, 0x1p+124 , 0x1.111111111111p+48 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0011111111111111, 0x1p+124 , 0x1.1111111111111p+52 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x0111111111111111, 0x1p+124 , 0x1.11111111111111p+56 },
+{ ((__int128_t)0x1000000000000000 << 64) | 0x1111111111111111, 0x1p+124 , 0x1.111111111111111p+60 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0xf000000000000000, -0x1p+60 , 0x0p+0 },
+{ ((__int128_t)0xffffffffffffffff << 64) | 0xff00000000000000, -0x1p+56 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xb7ffffff77ffffff, 0x1.6ffffffefp+63, -0x1p+0 },
+{ ((__int128_t)0xb7ffffff3fffffff << 64) | 0xb7ffffff3fffffff, -0x1.20000003p+126 , -0x1.20000003p+62 },
+{ ((__int128_t)0xb7fffffefffffffe << 64) | 0xb7fffffefffffffe, -0x1.20000004p+126 , -0x1.48000001p+64 },
+{ ((__int128_t)0xb7fffffeffffefff << 64) | 0xb7fffffeffffefff, -0x1.2000000400004p+126 , -0x1.2000000400004p+62 },
+{ ((__int128_t)0x0000040000000000 << 64) | 0x0000000000000000, 0x1p+106 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x000000003ff00000, 0x1.ff8p+29 , 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xb7fbffffffffdfff, 0x1.6ff7ffffffffcp+63 , -0x1p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x4804000000010000, 0x1.201000000004p+62, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x4900000000001000, 0x1.2400000000004p+62, 0x0p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0xb6ffffffffffefff, 0x1.6dffffffffffep+63, -0x1p+0 },
+{ ((__int128_t)0x0000000000000000 << 64) | 0x4900000000008000, 0x1.240000000002p+62, 0x0p+0 },
+{ ((__int128_t)0xb6ffffffffff7fff << 64) | 0xb6ffffffffff7fff, -0x1.240000000002p+126, -0x1.240000000002p+62 },
+{ ((__int128_t)0x4900000000040000 << 64) | 0x4900000000040000, 0x1.24000000001p+126 , 0x1.24000000001p+62 },
+{ ((__int128_t)0xb6fffffffffbffff << 64) | 0xb6fffffffffbffff, -0x1.24000000001p+126 , -0x1.24000000001p+62 },
+{ ((__int128_t)0x4900000000200000 << 64) | 0x4900000000200000, 0x1.24000000008p+126 , 0x1.24000000008p+62 },
+{ ((__int128_t)0xb6ffffffffdfffff << 64) | 0xb6ffffffffdfffff, -0x1.24000000008p+126 , -0x1.24000000008p+62 },
+{ ((__int128_t)0x4900000000800000 << 64) | 0x4900000000800000, 0x1.2400000002p+126 , 0x1.2400000002p+62 },
+{ ((__int128_t)0xb6ffffffff7fffff << 64) | 0xb6ffffffff7fffff, -0x1.2400000002p+126 , -0x1.2400000002p+62 },
+{ ((__int128_t)0x4900000008000000 << 64) | 0x4900000008000000, 0x1.240000002p+126 , 0x1.240000002p+62 },
+{ ((__int128_t)0xb6fffffff7ffffff << 64) | 0xb6fffffff7ffffff, -0x1.240000002p+126 , -0x1.240000002p+62 },
+{ ((__int128_t)0x4900000040000000 << 64) | 0x4900000040000000, 0x1.24000001p+126 , 0x1.24000001p+62 },
+{ ((__int128_t)0xb6ffffffbfffffff << 64) | 0xb6ffffffbfffffff, -0x1.24000001p+126 , -0x1.24000001p+62 },
+{ ((__int128_t)0x4900000080000000 << 64) | 0x4900000080000000, 0x1.24000002p+126 , 0x1.24000002p+62 },
+{ ((__int128_t)0xb6ffffff7fffffff << 64) | 0xb6ffffff7fffffff, -0x1.24000002p+126 , -0x1.24000002p+62 },
+{ ((__int128_t)0x4900000400000000 << 64) | 0x4900000400000000, 0x1.2400001p+126 , 0x1.2400001p+62 },
+{ ((__int128_t)0xb6fffffbffffffff << 64) | 0xb6fffffbffffffff, -0x1.2400001p+126 , -0x1.2400001p+62 },
+{ ((__int128_t)0x4900001000000000 << 64) | 0x4900001000000000, 0x1.2400004p+126 , 0x1.2400004p+62 },
+{ ((__int128_t)0xb6ffffefffffffff << 64) | 0xb6ffffefffffffff, -0x1.2400004p+126 , -0x1.2400004p+62 },
+{ ((__int128_t)0x4900004000000000 << 64) | 0x4900004000000000, 0x1.240001p+126 , 0x1.240001p+62 },
+{ ((__int128_t)0xb6ffffbfffffffff << 64) | 0xb6ffffbfffffffff, -0x1.240001p+126 , -0x1.240001p+62 },
+{ ((__int128_t)0x4900040000000000 << 64) | 0x4900040000000000, 0x1.24001p+126 , 0x1.24001p+62 },
+{ ((__int128_t)0xb6fffbffffffffff << 64) | 0xb6fffbffffffffff, -0x1.24001p+126 , -0x1.24001p+62 },
+{ ((__int128_t)0x4900200000000000 << 64) | 0x4900200000000000, 0x1.24008p+126 , 0x1.24008p+62 },
+{ ((__int128_t)0xb6ffdfffffffffff << 64) | 0xb6ffdfffffffffff, -0x1.24008p+126 , -0x1.24008p+62 },
+{ ((__int128_t)0x4901000000000000 << 64) | 0x4901000000000000, 0x1.2404p+126 , 0x1.2404p+62 },
+{ ((__int128_t)0xb6feffffffffffff << 64) | 0xb6feffffffffffff, -0x1.2404p+126 , -0x1.2404p+62 },
+{ ((__int128_t)0x4910000000000000 << 64) | 0x4910000000000000, 0x1.244p+126 , 0x1.244p+62 },
+{ ((__int128_t)0xb6efffffffffffff << 64) | 0xb6efffffffffffff, -0x1.244p+126, -0x1.244p+62 },
+{ ((__int128_t)0x4980000000000000 << 64) | 0x4980000000000000, 0x1.26p+126 , 0x1.26p+62 },
+{ ((__int128_t)0xb67fffffffffffff << 64) | 0xb67fffffffffffff, -0x1.26p+126 , -0x1.26p+62 },
+{ ((__int128_t)0x4c00000000000000 << 64) | 0x4c00000000000000, 0x1.3p+126 , 0x1.3p+62 },
+{ ((__int128_t)0xb3ffffffffffffff << 64) | 0xb3ffffffffffffff, -0x1.3p+126 , -0x1.3p+62 },
+{ ((__int128_t)0x9fffffffffffbfff << 64) | 0x9fffffffffffbfff, -0x1.800000000001p+126 , -0x1.800000000001p+62 },
+{ ((__int128_t)0x6000000000004001 << 64) | 0x6000000000004001, 0x1.800000000001p+126 , 0x1.6000000000004p+64 },
+{ ((__int128_t)0x8fffffffffffffbf << 64) | 0x8fffffffffffffbf, -0x1.cp+126 , -0x1.01cp+70 },
+{ ((__int128_t)0x7000000000000080 << 64) | 0x7000000000000080, 0x1.cp+126 , 0x1.00ep+71 },
+{ ((__int128_t)0x8fffffffffffff7f << 64) | 0x8fffffffffffff7f, -0x1.cp+126 , -0x1.00ep+71 },
+{ ((__int128_t)0x7000000000000800 << 64) | 0x7000000000000800, 0x1.c000000000002p+126 , 0x1.c000000000002p+62 },
+{ ((__int128_t)0x8ffffffffffff7ff << 64) | 0x8ffffffffffff7ff, -0x1.c000000000002p+126 , -0x1.c000000000002p+62 },
+{ ((__int128_t)0x7000000000002000 << 64) | 0x7000000000002000, 0x1.c000000000008p+126 , 0x1.c000000000008p+62 },
+{ ((__int128_t)0x8fffffffffffdfff << 64) | 0x8fffffffffffdfff, -0x1.c000000000008p+126 , -0x1.c000000000008p+62 },
+{ ((__int128_t)0x7000000000010000 << 64) | 0x7000000000010000, 0x1.c00000000004p+126 , 0x1.c00000000004p+62 },
+{ ((__int128_t)0x8ffffffffffeffff << 64) | 0x8ffffffffffeffff, -0x1.c00000000004p+126 , -0x1.c00000000004p+62 },
+{ ((__int128_t)0x7000000000040000 << 64) | 0x7000000000040000, 0x1.c0000000001p+126 , 0x1.c0000000001p+62 },
+{ ((__int128_t)0x8ffffffffffbffff << 64) | 0x8ffffffffffbffff, -0x1.c0000000001p+126 , -0x1.c0000000001p+62 },
+{ ((__int128_t)0x7000000000080000 << 64) | 0x7000000000080000, 0x1.c0000000002p+126 , 0x1.c0000000002p+62 },
+{ ((__int128_t)0x8ffffffffff7ffff << 64) | 0x8ffffffffff7ffff, -0x1.c0000000002p+126 , -0x1.c0000000002p+62 },
+{ ((__int128_t)0x7000000000800000 << 64) | 0x7000000000800000, 0x1.c000000002p+126 , 0x1.c000000002p+62 },
+{ ((__int128_t)0x8fffffffff7fffff << 64) | 0x8fffffffff7fffff, -0x1.c000000002p+126 , -0x1.c000000002p+62 },
+{ ((__int128_t)0x7000000008000000 << 64) | 0x7000000008000000, 0x1.c00000002p+126 , 0x1.c00000002p+62 },
+{ ((__int128_t)0x8ffffffff7ffffff << 64) | 0x8ffffffff7ffffff, -0x1.c00000002p+126 , -0x1.c00000002p+62 },
+{ ((__int128_t)0x7000000010000000 << 64) | 0x7000000010000000, 0x1.c00000004p+126 , 0x1.c00000004p+62 },
+{ ((__int128_t)0x8fffffffefffffff << 64) | 0x8fffffffefffffff, -0x1.c00000004p+126 , -0x1.c00000004p+62 },
+{ ((__int128_t)0x7000000100000000 << 64) | 0x7000000100000000, 0x1.c0000004p+126 , 0x1.c0000004p+62 },
+{ ((__int128_t)0x8ffffffeffffffff << 64) | 0x8ffffffeffffffff, -0x1.c0000004p+126 , -0x1.c0000004p+62 },
+{ ((__int128_t)0x7000000200000000 << 64) | 0x7000000200000000, 0x1.c0000008p+126 , 0x1.c0000008p+62 },
+{ ((__int128_t)0x8ffffffdffffffff << 64) | 0x8ffffffdffffffff, -0x1.c0000008p+126 , -0x1.c0000008p+62 },
+{ ((__int128_t)0x7000000800000000 << 64) | 0x7000000800000000, 0x1.c000002p+126 , 0x1.c000002p+62 },
+{ ((__int128_t)0x8ffffff7ffffffff << 64) | 0x8ffffff7ffffffff, -0x1.c000002p+126 , -0x1.c000002p+62 },
+{ ((__int128_t)0x7000008000000000 << 64) | 0x7000008000000000, 0x1.c00002p+126 , 0x1.c00002p+62 },
+{ ((__int128_t)0x8fffff7fffffffff << 64) | 0x8fffff7fffffffff, -0x1.c00002p+126 , -0x1.c00002p+62 },
+{ ((__int128_t)0x7000010000000000 << 64) | 0x7000010000000000, 0x1.c00004p+126 , 0x1.c00004p+62 },
+{ ((__int128_t)0x8ffffeffffffffff << 64) | 0x8ffffeffffffffff, -0x1.c00004p+126 , -0x1.c00004p+62 },
+{ ((__int128_t)0x7000080000000000 << 64) | 0x7000080000000000, 0x1.c0002p+126 , 0x1.c0002p+62 },
+{ ((__int128_t)0x8ffff7ffffffffff << 64) | 0x8ffff7ffffffffff, -0x1.c0002p+126 , -0x1.c0002p+62 },
+{ ((__int128_t)0x7000800000000000 << 64) | 0x7000800000000000, 0x1.c002p+126 , 0x1.c002p+62 },
+{ ((__int128_t)0x8fff7fffffffffff << 64) | 0x8fff7fffffffffff, -0x1.c002p+126 , -0x1.c002p+62 },
+{ ((__int128_t)0x7002000000000000 << 64) | 0x7002000000000000, 0x1.c008p+126 , 0x1.c008p+62 },
+{ ((__int128_t)0x8ffdffffffffffff << 64) | 0x8ffdffffffffffff, -0x1.c008p+126 , -0x1.c008p+62 },
+{ ((__int128_t)0x7008000000000000 << 64) | 0x7008000000000000, 0x1.c02p+126 , 0x1.c02p+62 },
+{ ((__int128_t)0x8ff7ffffffffffff << 64) | 0x8ff7ffffffffffff, -0x1.c02p+126 , -0x1.c02p+62 },
+{ ((__int128_t)0x7080000000000000 << 64) | 0x7080000000000000, 0x1.c2p+126 , 0x1.c2p+62 },
+{ ((__int128_t)0x8f7fffffffffffff << 64) | 0x8f7fffffffffffff, -0x1.c2p+126 , -0x1.c2p+62 },
+{ ((__int128_t)0x7400000000000000 << 64) | 0x7400000000000000, 0x1.dp+126 , 0x1.dp+62 },
+};
+
+static const int numTests = sizeof(tests) / sizeof(struct testCase);

compiler-rt/test/builtins/Unit/ppc/floattitf_test.c

+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
+
+/*
+* Test case execution for: long double __floattitf (__int128_t)
+* Conversion from 128 bit integer to long double (IBM double-double).
+*/
+
+#include <stdint.h>
+#include <stdio.h>
+
+long double __floattitf(__int128_t);
+
+#include "floattitf_test.h"
+#include "DD.h"
+
+int main(int argc, char *argv[]) {
+  /* Necessary long double and 128 bit integer declarations used to
+   * compare computed and expected high and low portions of the
+   * IBM double-double. */
+  DD expected_ld;
+  DD computed_ld;
+  __int128_t result128;
+
+  for (int i = 0; i < numTests; ++i) {
+    /* Set the expected high and low values of the long double,
+     * and the 128 bit integer input to be converted. */
+    expected_ld.hi = tests[i].hi;
+    expected_ld.lo = tests[i].lo;
+    result128 = tests[i].input128;
+
+    /* Get the computed long double from the int128->long double conversion
+     * and check for errors between high and low portions. */
+    computed_ld.ld = __floattitf(result128);
+
+    if ((computed_ld.hi != expected_ld.hi) ||
+        (computed_ld.lo != expected_ld.lo)) {
+
+      printf("Error on __floattitf( 0x%016llx 0x%016llx ):\n",
+             (long long) (tests[i].input128 >> 64),
+             (long long) tests[i].input128);
+      printf("\tExpected value - %La = ( %a, %a )\n",
+             expected_ld.ld, expected_ld.hi, expected_ld.lo);
+      printf("\tComputed value - %La = ( %a, %a )\n\n",
+             computed_ld.ld, computed_ld.hi, computed_ld.lo);
+
+      return 1;
+    }
+  }
+
+  return 0;
+}