[VE] Disable incompatible compiler-rt tests

[simoll]

Summary

Some compiler-rt tests are inherently incompatible with VE because..

• No consistent denormal support on VE. We skip denormal fp inputs in builtin tests.
• madvise unsupported on VE.
• Instruction alignment requirements.

[phosek]

compiler-rt/lib/profile/InstrProfilingUtil.c

368

I'd prefer changing the condition here instead.

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

32–33

INSTR_ALIGNMENT_BYTE isn't used anywhere else so I'd prefer inlining it here.

[simoll]

Addressed phosek's comments (thx!)

[phosek]

LGTM

[simoll]

NFC

• remove spurious newline
• #ifdef-out entire body of lprofReleaseMemoryPagesToOS for VE (MADV_DONTNEED isn't defined).

compiler-rt/lib/profile/InstrProfilingUtil.c

 #elif defined(__FreeBSD__)
   int PEnableSig = SIGKILL;
   procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &PEnableSig);
 #endif
 }
 
 COMPILER_RT_VISIBILITY int lprofReleaseMemoryPagesToOS(uintptr_t Begin,
                                                        uintptr_t End) {
+#if defined(__ve__)
+  // VE doesn't support madvise.
+  return 0;
+#else
   size_t PageSize = getpagesize();
   uintptr_t BeginAligned = lprofRoundUpTo((uintptr_t)Begin, PageSize);
   uintptr_t EndAligned = lprofRoundDownTo((uintptr_t)End, PageSize);
   if (BeginAligned < EndAligned) {
 #if defined(__Fuchsia__)
     return _zx_vmar_op_range(_zx_vmar_root_self(), ZX_VMAR_OP_DECOMMIT,
                              (zx_vaddr_t)BeginAligned,
                              EndAligned - BeginAligned, NULL, 0);
 #else
     return madvise((void *)BeginAligned, EndAligned - BeginAligned,
                    MADV_DONTNEED);
 #endif
   }
   return 0;
+#endif
 }

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define DOUBLE_PRECISION
 #include <math.h>
 #include <stdio.h>
 #include "fp_lib.h"
 
 int test__compiler_rt_logb(fp_t x) {
+#if defined(__ve__)
+  if (fpclassify(x) == FP_SUBNORMAL)
+    return 0;
+#endif
   fp_t crt_value = __compiler_rt_logb(x);
   fp_t libm_value = logb(x);
   // Compare the values, considering all NaNs equivalent, as the spec doesn't
   // specify the NaN signedness/payload.
   if (crt_value != libm_value &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {
     printf("error: in __compiler_rt_logb(%a [%lX]) = %a [%lX] !=  %a [%lX]\n",
            x, toRep(x), crt_value, toRep(crt_value), libm_value,

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
 #include "int_math.h"
 #include <math.h>
 #include <stdio.h>
 
 int test__compiler_rt_logbf(fp_t x) {
+#if defined(__ve__)
+  if (fpclassify(x) == FP_SUBNORMAL)
+    return 0;
+#endif
   fp_t crt_value = __compiler_rt_logbf(x);
   fp_t libm_value = logbf(x);
   // `!=` operator on fp_t returns false for NaNs so also check if operands are
   // both NaN. We don't do `toRepr(crt_value) != toRepr(libm_value)` because
   // that treats different representations of NaN as not equivalent.
   if (crt_value != libm_value &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {
     printf("error: in __compiler_rt_logb(%a [%X]) = %a [%X] !=  %a [%X]\n", x,

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define QUAD_PRECISION
 #include <math.h>
 #include <stdio.h>
 #include "fp_lib.h"
 #include "int_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
 
 int test__compiler_rt_logbl(fp_t x) {
+#if defined(__ve__)
+  if (fpclassify(x) == FP_SUBNORMAL)
+    return 0;
+#endif
   fp_t crt_value = __compiler_rt_logbl(x);
   fp_t libm_value = logbl(x);
   // Compare the values, considering all NaNs equivalent, as the spec doesn't
   // specify the NaN signedness/payload.
   if (crt_value != libm_value &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {
     // Split expected values into two for printf
     twords x_t, crt_value_t, libm_value_t;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define DOUBLE_PRECISION
 #include <fenv.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdio.h>
 #include "fp_lib.h"
 
 int test__compiler_rt_scalbn(const char *mode, fp_t x, int y) {
+#if defined(__ve__)
+  if (fpclassify(x) == FP_SUBNORMAL)
+    return 0;
+#endif
   fp_t crt_value = __compiler_rt_scalbn(x, y);
   fp_t libm_value = scalbn(x, y);
   // Consider +/-0 unequal, but disregard the sign/payload of NaN.
   if (toRep(crt_value) != toRep(libm_value) &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {
     printf("error: [%s] in __compiler_rt_scalbn(%a [%llX], %d) = %a [%llX] "
            "!= %a [%llX]\n",
            mode, x, (unsigned long long)toRep(x), y,

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define SINGLE_PRECISION
 #include <fenv.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdio.h>
 #include "fp_lib.h"
 
 int test__compiler_rt_scalbnf(const char *mode, fp_t x, int y) {
+#if defined(__ve__)
+  if (fpclassify(x) == FP_SUBNORMAL)
+    return 0;
+#endif
   fp_t crt_value = __compiler_rt_scalbnf(x, y);
   fp_t libm_value = scalbnf(x, y);
   // Consider +/-0 unequal, but disregard the sign/payload of NaN.
   if (toRep(crt_value) != toRep(libm_value) &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {
     printf("error: [%s] in __compiler_rt_scalbnf(%a [%X], %d) = %a [%X] "
            "!= %a [%X]\n",
            mode, x, toRep(x), y, crt_value, toRep(crt_value),

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 
 #define QUAD_PRECISION
 #include <fenv.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdio.h>
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
 
 int test__compiler_rt_scalbnl(const char *mode, fp_t x, int y) {
+#if defined(__ve__)
+  if (fpclassify(x) == FP_SUBNORMAL)
+    return 0;
+#endif
   fp_t crt_value = __compiler_rt_scalbnl(x, y);
   fp_t libm_value = scalbnl(x, y);
   // Consider +/-0 unequal, but disregard the sign/payload of NaN.
   if (toRep(crt_value) != toRep(libm_value) &&
       !(crt_isnan(crt_value) && crt_isnan(libm_value))) {
     // Split expected values into two for printf
     twords x_t, crt_value_t, libm_value_t;
     x_t.all = toRep(x);

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

return (void *)((uintptr_t)memcpy(dst, (void *)((uintptr_t)src & ~1), n) |
                   ((uintptr_t)src & 1));
 #else
   return memcpy(dst, (void *)((uintptr_t)src), n);
 #endif
 }
 
 int main()
 {
+#if defined(__ve__)
+    unsigned char execution_buffer[128] __attribute__((__aligned__(8)));
+#else
     unsigned char execution_buffer[128];
+#endif
     // mark stack page containing execution_buffer to be executable
     __enable_execute_stack(execution_buffer);
   
     // verify you can copy and execute a function
     pfunc f1 = (pfunc)memcpy_f(execution_buffer, func1, 128);
     __clear_cache(execution_buffer, &execution_buffer[128]);
     printf("f1: %p\n", f1);
     if ((*f1)() != 1)