The following functions and tests work fine for powerpc64, so enable them.

[saugustine]

Summary

These functions were disabled for powerpc in the initial
checkin all the way back in 2009. The reasons why are lost to history,
but they work fine with modern clang and powerpc64. I have no way
to test them on 32-bit systems, but will clean this up if the someone
finds a failure.

[saugustine]

Anyone have any opinions on this?

[aheejin]

I don't have enough context or knowledge on this code base. Sorry!

[nemanjai]

In D36764#843778, @saugustine wrote:

Anyone have any opinions on this?

I don't see an issue with providing these functions on PowerPC as there doesn't seem to be anything in the implementation that PowerPC would have an issue with. However, I'm not sure if there are precision specifications for these builtins. If so, it is quite possible that PowerPC's long double won't meet those specifications. For the time being, the PPC long double is not IEEE 754 compliant - it's a pair of doubles.

[joerg]

Because PPC uses the TC variant.

[nemanjai]

In D36764#844486, @joerg wrote:

Because PPC uses the TC variant.

Sorry, I don't understand this comment. What is the "TC variant"?

[joerg]

divtc3 and friends.

[nemanjai]

In D36764#844692, @joerg wrote:

divtc3 and friends.

Ah, OK. I see what you mean now. These builtins are for XCmode calculations (complex values as two XFmode components). Since PPC has no support for XFmode (i.e. 80-bit long double) in HW (and I don't imagine emulation is useful), I'm not sure it's meaningful to expose these builtins.

That's at least my interpretation, but please let me know if I'm way off base with that analysis.

[saugustine]

OK. I understand how these should work now.

As they are 80-bit specific, I am going to abandon this change and add them to my other patch which moves 80-bit specific floats and tests to x86-specific lists.

compiler-rt/lib/builtins/divxc3.c

 /* ===-- divxc3.c - Implement __divxc3 -------------------------------------===
  *
  *                     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 __divxc3 for the compiler_rt library.
  *
  */
 
-#if !_ARCH_PPC
-
 #include "int_lib.h"
 #include "int_math.h"
 
 /* Returns: the quotient of (a + ib) / (c + id) */
 
 COMPILER_RT_ABI Lcomplex
 __divxc3(long double __a, long double __b, long double __c, long double __d)
 {
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
             __c = crt_copysignl(crt_isinf(__c) ? 1 : 0, __c);
             __d = crt_copysignl(crt_isinf(__d) ? 1 : 0, __d);
             COMPLEX_REAL(z) = 0 * (__a * __c + __b * __d);
             COMPLEX_IMAGINARY(z) = 0 * (__b * __c - __a * __d);
         }
     }
     return z;
 }
-
-#endif

compiler-rt/lib/builtins/mulxc3.c

 /* ===-- mulxc3.c - Implement __mulxc3 -------------------------------------===
  *
  *                     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 __mulxc3 for the compiler_rt library.
  *
  * ===----------------------------------------------------------------------===
  */
 
-#if !_ARCH_PPC
-
 #include "int_lib.h"
 #include "int_math.h"
 
 /* Returns: the product of a + ib and c + id */
 
 COMPILER_RT_ABI Lcomplex
 __mulxc3(long double __a, long double __b, long double __c, long double __d)
 {
if (crt_isnan(COMPLEX_REAL(z)) && crt_isnan(COMPLEX_IMAGINARY(z)))
         if (__recalc)
         {
             COMPLEX_REAL(z) = CRT_INFINITY * (__a * __c - __b * __d);
             COMPLEX_IMAGINARY(z) = CRT_INFINITY * (__a * __d + __b * __c);
         }
     }
     return z;
 }
-
-#endif

compiler-rt/lib/builtins/powixf2.c

 /* ===-- powixf2.cpp - Implement __powixf2 ---------------------------------===
  *
  *                     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 __powixf2 for the compiler_rt library.
  *
  * ===----------------------------------------------------------------------===
  */
 
-#if !_ARCH_PPC
-
 #include "int_lib.h"
 
 /* Returns: a ^ b */
 
 COMPILER_RT_ABI long double
 __powixf2(long double a, si_int b)
 {
     const int recip = b < 0;
     long double r = 1;
     while (1)
     {
         if (b & 1)
             r *= a;
         b /= 2;
         if (b == 0)
             break;
         a *= a;
     }
     return recip ? 1/r : r;
 }
-
-#endif

compiler-rt/test/builtins/Unit/divxc3_test.c

 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
-// UNSUPPORTED: powerpc64
 //===-- divxc3_test.c - Test __divxc3 -------------------------------------===//
 //
 //                     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 tests __divxc3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
-#if !_ARCH_PPC
-
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // UNSUPPORTED: mips
 // REQUIRES: c99-complex
 
long double x[][2] =
     {+0., INFINITY},
     {0.5, INFINITY},
     {1, INFINITY},
     {2, INFINITY},
     {INFINITY, INFINITY}
 
 };
 
-#endif
-
 int main()
 {
-#if !_ARCH_PPC
     const unsigned N = sizeof(x) / sizeof(x[0]);
     unsigned i, j;
     for (i = 0; i < N; ++i)
     {
         for (j = 0; j < N; ++j)
         {
             if (test__divxc3(x[i][0], x[i][1], x[j][0], x[j][1]))
                 return 1;
         }
     }
 
-#else
-    printf("skipped\n");
-#endif
     return 0;
 }

compiler-rt/test/builtins/Unit/mulxc3_test.c

 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
-// UNSUPPORTED: powerpc64
 //===-- mulxc3_test.c - Test __mulxc3 -------------------------------------===//
 //
 //                     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 tests __mulxc3 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
-#if !_ARCH_PPC
-
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 // UNSUPPORTED: mips
 // REQUIRES: c99-complex
 
long double x[][2] =
     {+0., INFINITY},
     {0.5, INFINITY},
     {1, INFINITY},
     {2, INFINITY},
     {INFINITY, INFINITY}
 
 };
 
-#endif
-
 int main()
 {
-#if !_ARCH_PPC
     const unsigned N = sizeof(x) / sizeof(x[0]);
     unsigned i, j;
     for (i = 0; i < N; ++i)
     {
         for (j = 0; j < N; ++j)
         {
             if (test__mulxc3(x[i][0], x[i][1], x[j][0], x[j][1]))
                 return 1;
         }
     }
 
-#else
-    printf("skipped\n");
-#endif
     return 0;
 }

compiler-rt/test/builtins/Unit/powixf2_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
-// UNSUPPORTED: powerpc64
 //===-- powixf2_test.cpp - Test __powixf2 ---------------------------------===//
 //
 //                     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 tests __powixf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
-#if !_ARCH_PPC
-
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
 COMPILER_RT_ABI long double __powixf2(long double a, si_int b);
 
 int test__powixf2(long double a, si_int b, long double expected)
 {
     long double x = __powixf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powixf2(%Lf, %d) = %Lf, expected %Lf\n",
                a, b, x, expected);
     return !correct;
 }
 
-#endif
-
 int main()
 {
-#if !_ARCH_PPC
     if (test__powixf2(0, 0, 1))
         return 1;
     if (test__powixf2(1, 0, 1))
         return 1;
     if (test__powixf2(1.5, 0, 1))
         return 1;
     if (test__powixf2(2, 0, 1))
         return 1;
if (test__powixf2(2, 31, 2147483648.))
         return 1;
     if (test__powixf2(-2, 31, -2147483648.))
         return 1;
     if (test__powixf2(2, -31, 1/2147483648.))
         return 1;
     if (test__powixf2(-2, -31, -1/2147483648.))
         return 1;
 
-#else
-    printf("skipped\n");
-#endif
     return 0;
 }