[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

370

I'd prefer changing the condition here instead.

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

37–38

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

 #else
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/file.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
+#ifdef __ve__
+// VE doesn't support madvise.  VE doesn't support paging, therefore VE's
+// madvise syscall returns success always.  VEOS doesn't define MADV_DONTNEED,
+// so defines it here.
+#define MADV_DONTNEED 4
+#endif
 #endif
 
 #ifdef COMPILER_RT_HAS_UNAME
 #include <sys/utsname.h>
 #endif
 
 #include <stdlib.h>
 #include <string.h>
COMPILER_RT_VISIBILITY int lprofReleaseMemoryPagesToOS(uintptr_t Begin,
   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;
 }

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

 // REQUIRES: native-run
 // RUN: %clang_builtins %s %librt -o %t && %run_nomprotect %t
 // REQUIRES: librt_has_enable_execute_stack
 
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
+
+#if defined(__ve__)
+#define INSTR_ALIGNMENT_BYTE 8
+#endif
+
 extern void __clear_cache(void* start, void* end);
 extern void __enable_execute_stack(void* addr);
 
 typedef int (*pfunc)(void);
 
 // Make these static to avoid ILT jumps for incremental linking on Windows.
 static int func1() { return 1; }
 static int func2() { return 2; }
 
 void *__attribute__((noinline))
 memcpy_f(void *dst, const void *src, size_t n) {
 // ARM and MIPS naturally align functions, but use the LSB for ISA selection
 // (THUMB, MIPS16/uMIPS respectively).  Ensure that the ISA bit is ignored in
 // the memcpy
 #if defined(__arm__) || defined(__mips__)
   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(INSTR_ALIGNMENT_BYTE)
+    unsigned char execution_buffer[128] __attribute__((__aligned__(INSTR_ALIGNMENT_BYTE)));
+#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)