[compiler-rt][builtins][PowerPC] Enable builtins tests on PowerPC 64 bit LE

[amyk]

Summary

This patch aims to enable the tests for the builtin functions (that currently already exist for PowerPC within compiler-rt) for PowerPC 64bit LE (ppc64le). Previously when regression tests are run, these tests would be reported as UNSUPPORTED, perhaps due to the incorrect target architecture.

The following changes were made in this patch:

• Updating the REQUIRES line for each test, to enable testing on ppc64le
• Adding %librt in the RUN line, to link against compiler-rt when running the tests

With this patch, seven tests are run, but two are failures. The failures are from floatditf.c and floatunditf.c respectively, due to the use of COMPILER_RT_ABI in these two test files. This patch will require input on whether or not COMPILER_RT_ABI should or should not be included within these tests.

[amyk]

@weimingz I noticed that you have previously added the REQUIRES and RUN lines to these tests, and have added you as a reviewer in regards to me updating the lines you have previously added.

[amyk]

@dschuff Is it possible to elaborate on why COMPILER_RT_ABI is needed in floatditf.c and floatunditf.c, and/of if it still needed?

[dschuff]

Conceptually, COMPILER_RT_ABI is the calling convention used by all compiler-rt functions. It is explicitly named and used because it may be different from the default calling convention on some targets. In practice I believe it only affects ARM, where the calling convention uses ARM's soft-float ABI (where IIRC floats are passed in integer registers) even on targets that use the hard-float ABI by default. The compiler knows the calling conventions and emits the right code when it emits the libcalls, and the ABI declaration on the implementations causes the right calling convention to be used there. The unusual thing about the tests is that they locally declare the compiler-rt functions explicitly. So this declaration has to match the implementation. It may not matter for PPC but my recommendation would be "just use it everywhere in compiler-rt" for simplicity.

[nemanjai]

In D54449#1296245, @dschuff wrote:

Conceptually, COMPILER_RT_ABI is the calling convention used by all compiler-rt functions. It is explicitly named and used because it may be different from the default calling convention on some targets. In practice I believe it only affects ARM, where the calling convention uses ARM's soft-float ABI (where IIRC floats are passed in integer registers) even on targets that use the hard-float ABI by default. The compiler knows the calling conventions and emits the right code when it emits the libcalls, and the ABI declaration on the implementations causes the right calling convention to be used there. The unusual thing about the tests is that they locally declare the compiler-rt functions explicitly. So this declaration has to match the implementation. It may not matter for PPC but my recommendation would be "just use it everywhere in compiler-rt" for simplicity.

Fair enough, but shouldn't the header used for the tests #include "lib/builtins/int_lib.h" in order to have the macro def available?

[amyk]

Are there any more comments regarding on if all of these tests should contain COMPILER_RT_ABI (and the relevant include statement) if all compiler-rt functions should have them anyway?

[nemanjai]

Let's add the #include for the file that defines the pertinent macros and push this change so we start running the test cases on PPC64LE.

compiler-rt/trunk/test/builtins/Unit/ppc/fixtfdi_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdio.h>
 #include <limits.h>
 #include <stdint.h>
 #include "DD.h"
 
 struct testVector { double xhi; double xlo; int64_t result; };
 
 #define INFINITY __builtin_inf()
if (computed_result != expected_result) {
       printf("\tExpected %016llx ( %lld )\n", expected_result, expected_result);
       printf("\tComputed %016llx ( %lld )\n", computed_result, computed_result);
       
       return 1;
     }
   }
   
   return 0;
-}
+}
 

compiler-rt/trunk/test/builtins/Unit/ppc/floatditf_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdint.h>
 #include <stdio.h>
+#include "int_lib.h"
 
 COMPILER_RT_ABI long double __floatditf(int64_t);
 
 #include "floatunditf_test.h"
 #include "DD.h"
 
 int main(int argc, char *argv[]) {
   int i;

compiler-rt/trunk/test/builtins/Unit/ppc/floatunditf_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdint.h>
 #include <stdio.h>
+#include "int_lib.h"
 
 COMPILER_RT_ABI long double __floatunditf(uint64_t);
 
 #include "floatunditf_test.h"
 #include "DD.h"
 
 int main(int argc, char *argv[]) {
   int i;

compiler-rt/trunk/test/builtins/Unit/ppc/qadd_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdio.h>
 #include "DD.h"
 
 long double __gcc_qadd(long double x, long double y);
 
 double testAccuracy();
 int testEdgeCases();
 

compiler-rt/trunk/test/builtins/Unit/ppc/qdiv_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdio.h>
 #include "DD.h"
 
 long double __gcc_qdiv(long double x, long double y);
 
 double testAccuracy();
 int testEdgeCases();
 

compiler-rt/trunk/test/builtins/Unit/ppc/qmul_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdio.h>
 #include "DD.h"
 
 long double __gcc_qmul(long double x, long double y);
 
 double testAccuracy();
 int testEdgeCases();
 

compiler-rt/trunk/test/builtins/Unit/ppc/qsub_test.c

-// REQUIRES: powerpc-registered-target
-// RUN: %clang_builtins %s -o %t && %run %t
+// REQUIRES: target-is-powerpc64le
+// RUN: %clang_builtins %s %librt -o %t && %run %t
 #include <stdio.h>
 #include "DD.h"
 
 long double __gcc_qsub(long double x, long double y);
 
 double testAccuracy();
 int testEdgeCases();