Port SingleSource tests to Windows

[omjavaid]

Summary

This patch attempts to port LLVM testsuite SingleSource tests to Windows.
There changes are mostly around handling inlined printf by adding stdio or
handling missing functions like gettimeofday. Also some tests require
compiler-rt builtin intrinsics and some needed libcmt.lib or other includes.
pthread usage has been replaced with std thread on windows. A cmake module
is borrowed from llvm-project/cmake/modules to detect the correct builtin
library for the current compiler.

To tests this do following in Visual Studio developer console with CC CXX set to
your test C/C++ compilers:

set CC=c:\\work\\llvm-dev\\build\\bin\\clang-cl.exe

set CXX=c:\\work\\llvm-dev\\build\\bin\\clang-cl.exe

cmake -G Ninja -DTEST_SUITE_SUBDIRS=SingleSource -DTEST_SUITE_COLLECT_COMPILE_TIME=OFF ..\\llvm-test-suite

CMakeLists.txt

 cmake_minimum_required(VERSION 3.13.4)
 
 include(CheckSymbolExists)
 
-
 project(test-suite C CXX)
 
 if("Fortran" IN_LIST TEST_SUITE_SUBDIRS)
   set(TEST_SUITE_FORTRAN_default ON)
 else()
   set(TEST_SUITE_FORTRAN_default OFF)
 endif()
 option(TEST_SUITE_FORTRAN "Enable Fortran test suite" ${TEST_SUITE_FORTRAN_default})
if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
   if(DEFINED ENV{OBJECT_MODE})
     # Specify maximum data heap size on AIX for 32-bit programs.
     if($ENV{OBJECT_MODE} STREQUAL "32")
       set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-bmaxdata:0x80000000")
     endif()
   endif()
 endif()
 
+include(HandleCompilerRT)
+
 include(TestSuite)
 include(SingleMultiSource)
 # Needs by External/sollve_vv.
 find_package(OpenMP)
 # Fortran Helper Modules
 if(TEST_SUITE_FORTRAN)
   include(Fortran)
 endif()

SingleSource/Benchmarks/BenchmarkGame/Large/fasta.c

 /* The Computer Language Benchmarks Game
  * http://shootout.alioth.debian.org/
  * Contributed by Joern Inge Vestgaarden
  * Modified by Jorge Peixoto de Morais Neto
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifndef _AIX
+
+#if !defined(_AIX) && !defined(_WIN32)
 #include <err.h>
 #endif
 
 #define WIDTH 60
 #define MIN(a,b) ((a) <= (b) ? (a) : (b))
 #define NELEMENTS(x) (sizeof (x) / sizeof ((x)[0]))
 
 typedef struct {

SingleSource/Benchmarks/CMakeLists.txt

 add_subdirectory(Adobe-C++)
 add_subdirectory(BenchmarkGame)
 add_subdirectory(CoyoteBench)
 add_subdirectory(Dhrystone)
 add_subdirectory(Linpack)
 add_subdirectory(McGill)
 add_subdirectory(Misc)
 add_subdirectory(Misc-C++)
 add_subdirectory(Misc-C++-EH)
 add_subdirectory(Polybench)
 add_subdirectory(Shootout)
 add_subdirectory(Shootout-C++)
-add_subdirectory(SmallPT)
 add_subdirectory(Stanford)
+if(NOT TARGET_OS STREQUAL "Windows")
+add_subdirectory(SmallPT) # Depends on erand48
+endif()

SingleSource/Benchmarks/McGill/misr.c

 #include <string.h>
 
 #define INF 10000
 #define MAX_REG_LN 100
 #define BIN_MASK 1
 #define TRUE 1
 #define FALSE 0
 
-#ifdef __MINGW32__
-# define seed48(x) srand(x)
-# define lrand48() ((rand() << 16) ^ (rand()))
+#if defined(_WIN32)
+#define seed48(seed) \
+    do { \
+        unsigned int combined_seed = ((seed)[0] << 16) ^ ((seed)[1] << 8) ^ (seed)[2]; \
+        srand(combined_seed); \
+    } while (0)
+
+#define lrand48() ((rand() << 16) ^ (rand()))
 #endif
 
 int reg_len;
 
 typedef struct cells {
         int f_free;
   int faulty;
         struct cells *next;

SingleSource/Benchmarks/Misc-C++-EH/spirit.cpp

private:
             return ptr.get();
         }
         rule(abstract_parser_t const* ptr)
         : ptr(ptr) {}
         scoped_ptr<abstract_parser_t> ptr;
     };
 }}
 #include <assert.h>
+#ifdef _WIN32
+#include <thread>
+#include <mutex>
+#else
 #include <pthread.h>
+#endif
 namespace boost
 {
 namespace detail
 {
 #ifdef __XS1B__
 class lightweight_mutex {
 public:
     class scoped_lock {
     public:
         scoped_lock(lightweight_mutex & m){}
     };
     friend class scoped_lock;
 };
 #else
 class lightweight_mutex
 {
 private:
-    pthread_mutex_t m_;
+#ifdef _WIN32
+    std::mutex m_;
+#else
+  pthread_mutex_t m_; 
+#endif
     lightweight_mutex(lightweight_mutex const &);
     lightweight_mutex & operator=(lightweight_mutex const &);
 public:
     lightweight_mutex()
     {
+#ifndef _WIN32
         pthread_mutex_init(&m_, 0);
+#endif
     }
     ~lightweight_mutex()
     {
+#ifndef _WIN32
         pthread_mutex_destroy(&m_);
+#endif
     }
     class scoped_lock;
     friend class scoped_lock;
     class scoped_lock
     {
     private:
-        pthread_mutex_t & m_;
+#ifdef _WIN32
+    std::mutex &m_;
+#else
+    pthread_mutex_t & m_;
+#endif
         scoped_lock(scoped_lock const &);
         scoped_lock & operator=(scoped_lock const &);
     public:
         scoped_lock(lightweight_mutex & m): m_(m.m_)
         {
-            pthread_mutex_lock(&m_);
+#ifdef _WIN32
+      m_.lock();
+#else
+      pthread_mutex_lock(&m_);
+#endif
         }
         ~scoped_lock()
         {
-            pthread_mutex_unlock(&m_);
+#ifdef _WIN32
+      m_.unlock();
+#else
+      pthread_mutex_unlock(&m_);
+#endif
         }
     };
 };
 #endif
 }
 }
 namespace boost
 {

SingleSource/Benchmarks/Misc-C++/Large/sphereflake.cpp

if (n == 0)
     return 1;
   for (i=1; i<n; i++)
     res *= d;
   return res;
 }
 
 // Simplified Taylor series
 static double LLVMsin(double d) {
-  double sign = 1.0;
+  double sign = 1.0;
 
   /* move into 2PI area */
   while (d < 0)
     d += PI2;
   while (d > PI2)
     d -= PI2;
   /* move into PI/2 area */
   if (d > PI3_2) {
else
       b1=v_t(n.z,n.x,n.y);/*leaves some cases out,dodge them*/
     
     up=n;
     b2=up.cross(b1);
     b1=up.cross(b2);
   }
 };
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327950288
+#endif
+
 static node_t *create(node_t*n,const int lvl,int dist,v_t c,v_t d,double r) {
   n = 1 + new (n) node_t(sphere_t(c,2.*r),sphere_t(c,r), lvl > 1 ? dist : 1);
   if (lvl <= 1)
     return n; /*if not at the bottom, recurse a bit more*/
   
   dist=std::max((dist-childs)/childs,1); const basis_t b(d); 
   const double nr=r*1/3.,daL=2.*M_PI/6.,daU=2.*M_PI/3.; double a=0;
   for(int i=0;i<6;++i){ /*lower ring*/

SingleSource/Benchmarks/Misc/CMakeLists.txt

+if(TARGET_OS STREQUAL "Windows")
+  find_compiler_rt_library(COMPILER_RT_BUILTINS_LIBRARY)
+  list(APPEND LDFLAGS ${COMPILER_RT_BUILTINS_LIBRARY})
+else()
   list(APPEND LDFLAGS -lm )
+endif()
+
 list(APPEND CFLAGS -Wno-implicit-int)
 set(FP_TOLERANCE 0.001)
 set(Source
   ReedSolomon.c
   evalloop.c
   fbench.c
   ffbench.c
   flops-1.c
   flops-2.c
   flops-3.c
   flops-4.c
   flops-5.c
   flops-6.c
   flops-7.c
   flops-8.c
   flops.c
   fp-convert.c
   himenobmtxpa.c
   lowercase.c
-  mandel-2.c
   mandel.c
   matmul_f64_4x4.c
   oourafft.c
   perlin.c
   pi.c
   revertBits.c
   richards_benchmark.c
   salsa20.c
   whetstone.c
 )
+if(NOT TARGET_OS STREQUAL "Windows")
+  list(APPEND Source mandel-2.c)
+endif()
 if(NOT ARCH STREQUAL "PowerPC" OR NOT TARGET_OS STREQUAL "Darwin")
   list(APPEND Source dt.c)
 endif()
 llvm_singlesource()

SingleSource/Benchmarks/Misc/ReedSolomon.c

int main(void) {
   int i, j, k;
 
 #ifdef SMALL_PROBLEM_SIZE
 #define LENGTH 15000
 #else
 #define LENGTH 150000
 #endif
 
-#ifdef __MINGW32__
+#if defined(__MINGW32__) || defined(_WIN32)
 #define random() rand()
 #endif
 
   for (i=0; i<LENGTH; ++i) {
     /* Generate random data */
     for (j=0; j<188; ++j) {
       rs_in[j] = (random() & 0xFF);
     }

SingleSource/Benchmarks/Misc/dt.c

 
 // Can then hoist 1/tmp2 out of the loop if -ffast-math is enabled.
 }
 
 int main(int argc, char *argv[]) {
   double  *dvec1, *dvec2;
   long i;
 
+#ifdef _WIN32
+  dvec1 = _aligned_malloc(size * sizeof(double), 16);
+  dvec2 = _aligned_malloc(size * sizeof(double), 16);
+#else
   posix_memalign((void**)&dvec1, 16, size * sizeof(double));
   posix_memalign((void**)&dvec2, 16, size * sizeof(double));
+#endif
+
 
   printf( " %i iterations of each test. ", ITERATIONS );
   printf( " inner loop / array size %i.\n", size );
 
   // With better alias analysis of posix_memalign, we'd avoid reloading
   // dvec1/dvec2 each time through the loop.
   for( i = 0; i < size; i++ ) {
           dvec1[i] = 1.0000001 * cosf((float)(size - i));
           dvec2[i] = 1.0  + 0.0000000001 * sinf((float)i);
   }
 
   double_array_divs_variable( dvec1, dvec2 );
   printf("%f\n", dvec1[0]);
+
+#ifdef _WIN32
+  _aligned_free(dvec1);
+  _aligned_free(dvec2);
+#else
+  free(dvec1);
+  free(dvec2);
+#endif
   return 0;
 }
 

SingleSource/Benchmarks/Misc/flops.c

  return 0;
 }
 #endif
 
 /********************************************/
 /* Another UNIX timer using gettimeofday(). */
 /* However, getrusage() is preferred.       */
 /********************************************/
-#if defined(GTODay) && !defined(__MINGW32__)
+#if defined(GTODay) && !defined(__MINGW32__) && !defined(_WIN32)
 #include <sys/time.h>
 
 struct timeval tnow;
 
 dtime(p)
 double p[];
 {
  double q;

SingleSource/Benchmarks/Misc/himenobmtxpa.c

  wrk2 : working area, OMEGA : relaxation parameter
  BND:control variable for boundaries and objects ( = 0 or 1)
  P: pressure
 ********************************************************************/
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#ifndef _WIN32
 #include <sys/time.h>
+#else
+#include <Windows.h>
+#endif
 
 #define MR(mt,n,r,c,d)  mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
 
 struct Mat {
   float* m;
   int mnums;
   int mrows;
   int mcols;

 second()
 {
 
   struct timeval tm;
   double t ;
 
   static int base_sec = 0,base_usec = 0;
 
+#ifndef _WIN32
   gettimeofday(&tm, NULL);
-  
+#else
+  FILETIME ft;
+  ULARGE_INTEGER uli;
+
+  GetSystemTimeAsFileTime(&ft);
+  uli.LowPart = ft.dwLowDateTime;
+  uli.HighPart = ft.dwHighDateTime;
+
+  // Convert to microseconds (1 microsecond = 10^-6 seconds)
+  uli.QuadPart /= 10ULL; // Divide by 10 to convert 100ns intervals to microseconds
+
+  tm.tv_sec = (long)((uli.QuadPart - 11644473600000000ULL) / 1000000ULL); // Convert to Unix timestamp
+  tm.tv_usec = (long)(uli.QuadPart % 1000000ULL);
+#endif
   if(base_sec == 0 && base_usec == 0)
     {
       base_sec = tm.tv_sec;
       base_usec = tm.tv_usec;
       t = 0.0;
   } else {
     t = (double) (tm.tv_sec-base_sec) + 
       ((double) (tm.tv_usec-base_usec))/1.0e6 ;
   }
 
   return t ;
 }
 

SingleSource/Benchmarks/Misc/oourafft.c

 #include <math.h>
 #include <memory.h>
 #include <stdio.h>
 #include <stdlib.h>
 /* memalign */
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
-    !defined(__OpenBSD__) && !defined(_AIX)
+    !defined(__OpenBSD__) && !defined(_AIX) && !defined(_WIN32)
 #include <malloc.h>
 #endif
 
 /* random number generator, 0 <= RND < 1 */
 #define RND(p) ((*(p) = (*(p) * 7141 + 54773) % 259200) * (1.0 / 259200.0))
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
 
 void makewt(int nw, int *ip, double *w);
int main()
   /* Measure overhead of get_time() call */
   t_start = get_time();
   t_end = get_time();
   t_overhead = t_end - t_start;
 
   /* Prepare aux data */
   /* Darwin always 16-byte aligns malloc data */
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
-    !defined(__OpenBSD__) && !defined(_AIX)
+    !defined(__OpenBSD__) && !defined(_AIX) && !defined(_WIN32)
   ip = memalign(16, sqrt(N)*sizeof(int));
   w  = memalign(16, 2*N*5/4*sizeof(double));
 #else
   ip = malloc(sqrt(N)*sizeof(int));
   w  = malloc(2*N*5/4*sizeof(double));
 #endif
   makewt(N >> 1, ip, w);
   
   /* Allocate buffers */
   /* Darwin always 16-byte aligns malloc data */
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
-    !defined(__OpenBSD__) && !defined(_AIX)
+    !defined(__OpenBSD__) && !defined(_AIX) && !defined(_WIN32)
   ref = memalign(16, 2*N*sizeof(double));
   cmp = memalign(16, 2*N*sizeof(double));
   src = memalign(16, 2*N*sizeof(double));
 #else
   ref = malloc(2*N*sizeof(double));
   cmp = malloc(2*N*sizeof(double));
   src = malloc(2*N*sizeof(double));
 #endif
double errorcheck(int nini, int nend, double scale, double *a)
 
   for (j = nini; j <= nend; j++) {
     e = RND(&seed) - a[j] * scale;
     err = MAX(err, fabs(e));
   }
   return err;
 }
 
-#ifdef WIN32
+#ifdef _WIN32
+#undef N
 #include <windows.h>
 
 static LARGE_INTEGER t = {0, 0};
 
 double get_time(void)
 {
   LARGE_INTEGER l;
   if (t.QuadPart == 0)

SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c

 /**
  * correlation.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include "../../utilities/polybench.h"
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c

 /**
  * covariance.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include "../../utilities/polybench.h"
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c

 /**
  * 2mm.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c

 /**
  * 3mm.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c

 /**
  * atax.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */
 #include "atax.h"
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
 /* Array initialization. */
 static
 void init_array (int nx, int ny,
      DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
      DATA_TYPE POLYBENCH_1D(x,NY,ny))
 {
 #pragma STDC FP_CONTRACT OFF

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c

 /**
  * bicg.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */
 #include "bicg.h"
 
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
 
 /* Array initialization. */
 static
 void init_array (int nx, int ny,
      DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
      DATA_TYPE POLYBENCH_1D(r,NX,nx),
      DATA_TYPE POLYBENCH_1D(p,NY,ny))
 {

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c

 /**
  * cholesky.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c

 /**
  * doitgen.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c

 /**
  * gemm.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c

 /**
  * gemver.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c

 /**
  * gesummv.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c

 /**
  * mvt.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c

 /**
  * symm.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c

 /**
  * syr2k.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c

 /**
  * syrk.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c

 /**
  * trisolv.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c

 /**
  * trmm.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c

 /**
  * durbin.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 4000. */

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c

 /**
  * dynprog.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is int, default size is 50. */

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c

 /**
  * gramschmidt.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 512. */

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c

 /**
  * lu.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 1024. */

SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c

 /**
  * floyd-warshall.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 1024. */

SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c

 /**
  * reg_detect.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is int, default size is 50. */

SingleSource/Benchmarks/Polybench/stencils/adi/adi.c

 /**
  * adi.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 10x1024x1024. */

SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c

 /**
  * fdtd-2d.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 50x1000x1000. */

SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c

 /**
  * fdtd-apml.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 256x256x256. */

SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c

 /**
  * seidel-2d.c: This file is part of the PolyBench/C 3.2 test suite.
  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
 /* Include polybench common header. */
 #include <polybench.h>
 
 /* Include benchmark-specific header. */
 /* Default data type is double, default size is 20x1000. */

SingleSource/Benchmarks/Polybench/utilities/polybench.h

  *
  *
  * Contact: Louis-Noel Pouchet <[e-mail]>
  * Web address: http://polybench.sourceforge.net
  */
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <assert.h>
 #include <time.h>
+#ifndef _WIN32
+#include <unistd.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sched.h>
+#endif
 #include <math.h>
 #ifdef _OPENMP
 # include <omp.h>
 #endif
 
 /* By default, collect PAPI counters on thread 0. */
 #ifndef POLYBENCH_THREAD_MONITOR
 # define POLYBENCH_THREAD_MONITOR 0

 # ifndef POLYBENCH_CYCLE_ACCURATE_TIMER
   printf ("%0.6f\n", polybench_t_end - polybench_t_start);
 # else
   printf ("%Ld\n", polybench_c_end - polybench_c_start);
 # endif
 #endif
 }
 
-
+#ifdef _WIN32
+#include <malloc.h>
+#endif
 
 static
 void *
 xmalloc (size_t num)
 {
   void* new = NULL;
-  int ret = posix_memalign (&new, 32, num);
+  int ret = 0;
+#ifdef _WIN32
+  new = _aligned_malloc(num, 32);
+#else
+  ret = posix_memalign (&new, 32, num);
+#endif
   if (! new || ret)
   {
     fprintf (stderr, "[PolyBench] posix_memalign: cannot allocate memory");
     exit (1);
   }
   return new;
 }
 

SingleSource/Benchmarks/Shootout-C++/hash.cpp

 // -*- mode: c++ -*-
 // $Id$
 // http://www.bagley.org/~doug/shootout/
 
 #include <stdio.h>
 #include <iostream>
-#include <ext/hash_map>
 #include <cstring>
 
 using namespace std;
-using namespace __gnu_cxx;
 
-struct eqstr {
-    bool operator()(const char* s1, const char* s2) const {
-  return strcmp(s1, s2) == 0;
+struct eqstr
+{
+    bool operator()(const char *s1, const char *s2) const
+    {
+        return strcmp(s1, s2) == 0;
     }
 };
 
-int
-main(int argc, char *argv[]) {
+#ifdef _MSC_VER
+#include <unordered_map>
+typedef std::unordered_map<const char *, int, std::hash<const char *>, eqstr> HM;
+#else
+#include <ext/hash_map>
+using namespace __gnu_cxx;
+typedef __gnu_cxx::hash_map<const char *, int, __gnu_cxx::hash<const char *>, eqstr> HM;
+#endif
+
+int main(int argc, char *argv[])
+{
 #ifdef SMALL_PROBLEM_SIZE
 #define LENGTH 50000
 #else
 #define LENGTH 500000
 #endif
     int n = ((argc == 2) ? atoi(argv[1]) : LENGTH);
     char buf[16];
-    typedef __gnu_cxx::hash_map<const char*, int, __gnu_cxx::hash<const char*>, eqstr> HM;
     HM X;
 
-    for (int i=1; i<=n; i++) {
-  sprintf(buf, "%x", i);
-  X[strdup(buf)] = i;
+    for (int i = 1; i <= n; i++)
+    {
+        sprintf(buf, "%x", i);
+        X[strdup(buf)] = i;
     }
 
     int c = 0;
-    for (int i=n; i>0; i--) {
-  sprintf(buf, "%d", i);
-  if (X[strdup(buf)]) c++;
+    for (int i = n; i > 0; i--)
+    {
+        sprintf(buf, "%d", i);
+        if (X[strdup(buf)])
+            c++;
     }
 
     cout << c << endl;
 }

SingleSource/Benchmarks/Shootout-C++/hash2.cpp

 // -*- mode: c++ -*-
 // $Id$
 // http://www.bagley.org/~doug/shootout/
 
 #include <stdio.h>
 #include <iostream>
-#include <ext/hash_map>
 #include <cstring>
 
 using namespace std;
-using namespace __gnu_cxx;
 
 struct eqstr {
     bool operator()(const char* s1, const char* s2) const {
   return strcmp(s1, s2) == 0;
     }
 };
 
+#ifdef _MSC_VER
+#include <unordered_map>
+typedef std::unordered_map<const char *, int, std::hash<const char *>, eqstr> HM;
+#else
+#include <ext/hash_map>
+using namespace __gnu_cxx;
+typedef __gnu_cxx::hash_map<const char *, int, __gnu_cxx::hash<const char *>, eqstr> HM;
+#endif
+
 int
 main(int argc, char *argv[]) {
 #ifdef SMALL_PROBLEM_SIZE
 #define LENGTH 200
 #else
 #define LENGTH 2000
 #endif
     int n = ((argc == 2) ? atoi(argv[1]) : LENGTH);
     char buf[16];
-    typedef __gnu_cxx::hash_map<const char*, int, __gnu_cxx::hash<const char*>, eqstr> HM;
     HM hash1, hash2;
 
     for (int i=0; i<10000; i++) {
   sprintf(buf, "foo_%d", i);
   hash1[strdup(buf)] = i;
     }
     for (int i=0; i<n; i++) {
   for (HM::iterator k = hash1.begin(); k != hash1.end(); ++k) {
       hash2[(*k).first] += hash1[(*k).first];
   }
     }
     cout << hash1["foo_1"] << " " << hash1["foo_9999"] << " "
    << hash2["foo_1"] << " " << hash2["foo_9999"] << endl;
 }

SingleSource/Benchmarks/SmallPT/CMakeLists.txt

-list(APPEND CXXFLAGS -std=gnu++98)
+if(TARGET_OS STREQUAL "Windows")
+  find_compiler_rt_library(COMPILER_RT_BUILTINS_LIBRARY)
+  list(APPEND LDFLAGS lidcmt.lib ${COMPILER_RT_BUILTINS_LIBRARY})
+else()
   list(APPEND LDFLAGS -lm)
+endif()
+list(APPEND CXXFLAGS -std=gnu++98)
 set(FP_TOLERANCE 0.001)
 llvm_singlesource()

SingleSource/Regression/C/2004-08-12-InlinerAndAllocas.c

 // A compiler cannot inline Callee into main unless it is prepared to reclaim
 // the stack memory allocated in it.
 
-#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(_WIN32)
 #include <stdlib.h>
 #else
 #include <alloca.h>
 #endif
+
+#ifdef _WIN32
 #include <stdio.h>
+#include <malloc.h>
+#endif
 
 static int Callee(int i) {
   if (i != 0) {
     char *X = alloca(1000);
     sprintf(X, "%d\n", i);
     return X[0];
   }
   return 0;

SingleSource/Regression/C/CMakeLists.txt

+if(TARGET_OS STREQUAL "Windows")
+  find_compiler_rt_library(COMPILER_RT_BUILTINS_LIBRARY)
+  list(APPEND LDFLAGS libcmt.lib ${COMPILER_RT_BUILTINS_LIBRARY})
+else()
+  list(APPEND LDFLAGS -lm)
+endif()
+
 if(ARCH MATCHES "x86" OR ARCH MATCHES "riscv" OR
    ARCH MATCHES "SystemZ" OR ARCH MATCHES "Mips" OR
    ARCH MATCHES "AArch64" OR ARCH MATCHES "ARM" OR
    ARCH MATCHES "LoongArch")
   add_subdirectory(gcc-c-torture)
 endif()
 
-list(APPEND LDFLAGS -lm)
+if(TARGET_OS STREQUAL "Windows")
+  file(GLOB Source RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.c *.cpp)
+  list(REMOVE_ITEM Source uint64_to_float.c)
+  list(REMOVE_ITEM Source casts.c)
+endif()
+
 list(APPEND CFLAGS -Wno-implicit-int)
 llvm_singlesource(PREFIX "Regression-C-")

SingleSource/Regression/C/gcc-c-torture/execute/20021120-3.c

 /* Test whether a partly call-clobbered register will be moved over a call.
    Although the original test case didn't use any GNUisms, it proved
    difficult to reduce without the named register extension.  */
+#ifdef _WIN32
+#include<stdio.h>
+#endif
+
 #if __SH64__ == 32
 #define LOC asm ("r10")
 #else
 #define LOC
 #endif
 
 unsigned int foo (char *c, unsigned int x, unsigned int y)
 {

SingleSource/Regression/C/gcc-c-torture/execute/20030626-1.c

+#ifdef _WIN32
+#include<stdio.h>
+#endif
 char buf[10];
 
 extern void abort (void);
 extern int sprintf (char*, const char*, ...);
 
 int main()
 {
   int l = sprintf (buf, "foo\0bar");
   if (l != 3)
     abort ();
   return 0;
 }

SingleSource/Regression/C/gcc-c-torture/execute/20030626-2.c

+#ifdef _WIN32
+#include<stdio.h>
+#endif
 char buf[40];
 
 extern int sprintf (char*, const char*, ...);
 extern void abort (void);
 
 int main()
 {
   int i = 0;
   int l = sprintf (buf, "%s", i++ ? "string" : "other string");
   if (l != sizeof ("other string") - 1 || i != 1)
     abort ();
   return 0;
 }

SingleSource/Regression/C/gcc-c-torture/execute/20041214-1.c

 /* { dg-require-effective-target indirect_jumps } */
-
+#ifndef _WIN32
 typedef long unsigned int size_t;
+#endif
 extern void abort (void);
 extern char *strcpy (char *, const char *);
 extern int strcmp (const char *, const char *);
 typedef __builtin_va_list va_list;
 static const char null[] = "(null)";
 int g (char *s, const char *format, va_list ap)
 {
   const char *f;

SingleSource/Regression/C/gcc-c-torture/execute/20070201-1.c

 /* PR middle-end/30473 */
 
+#ifdef _WIN32
+#include<stdio.h>
+#else
 extern int sprintf (char *, const char *, ...);
 extern void abort (void);
+#endif
 
 char *
 foo (char *buf, char *p)
 {
   sprintf (buf, "abcde", p++);
   return p;
 }
 
 int
 main (void)
 {
   char buf[6];
   if (foo (buf, &buf[2]) != &buf[3])
     abort ();
   return 0;
 }

SingleSource/Regression/C/gcc-c-torture/execute/CMakeLists.txt

 add_subdirectory(ieee)
 
 # GCC C Torture Suite is conventionally run without warnings
 list(APPEND CFLAGS -Wno-implicit-int -Wno-int-conversion -Wno-implicit-function-declaration -w)
+if(TARGET_OS STREQUAL "Windows")
+  find_compiler_rt_library(COMPILER_RT_BUILTINS_LIBRARY)
+  list(APPEND LDFLAGS ${COMPILER_RT_BUILTINS_LIBRARY})
+endif()
 
 set(TestsToSkip)
 
 ##
 ## Main Test Blacklist for Clang
 ##
 
 # Tests with features unsupported by Clang (usually GCC extensions)
file(GLOB FailingTests CONFIGURE_DEPENDS
   # clang complains the array is too large
   991014-1.c
 
   # __builtin_setjmp/__builtin_longjmp are interacting badly with optimisation
   pr60003.c
 )
 list(APPEND TestsToSkip ${FailingTests})
 
+file(GLOB WindowsFailures CONFIGURE_DEPENDS
+
+  # Following tests do no compile with clang-cl on windows
+  fprintf-2.c  
+  printf-2.c
+  user-printf.c
+)
+list(APPEND TestsToSkip ${WindowsFailures})
+
 ##
 ## Tests that require extra CFLAGS in Clang
 ##
 
 # Tests that require -fwrapv
 file(GLOB TestRequiresFWrapV CONFIGURE_DEPENDS
   # Test relies on undefined signed overflow behavior (int foo - INT_MIN).
   20040409-1.c

SingleSource/Regression/C/gcc-c-torture/execute/pr78586.c

 /* PR tree-optimization/78586 */
+#ifdef _WIN32
+#include<stdio.h>
+#endif
 
 void
 foo (unsigned long x)
 {
   char a[30];
   unsigned long b = __builtin_sprintf (a, "%lu", x);
   if (b != 4)
     __builtin_abort ();
 }
 
 int
 main ()
 {
   foo (1000);
   return 0;
 }

SingleSource/Regression/C/gcc-c-torture/execute/pr79327.c

 /* PR tree-optimization/79327 */
 /* { dg-require-effective-target c99_runtime } */
+#ifdef _WIN32
+#include<stdio.h>
+#endif
 
 volatile int a;
 
 int
 main (void)
 {
   int i;
   char buf[64];

SingleSource/UnitTests/CMakeLists.txt

 include(CheckCCompilerFlag)
 
 add_subdirectory(C++11)
 add_subdirectory(Float)
 add_subdirectory(Matrix)
 add_subdirectory(SignlessTypes)
-add_subdirectory(Threads)
 add_subdirectory(Vector)
 add_subdirectory(Vectorizer)
 add_subdirectory(X86)
 
 list(APPEND CFLAGS -Wno-implicit-function-declaration -Wno-implicit-int)
 
 # FIXME: Disable SJLJ tests for now, until EH edges are represented.
 # add_subdirectory(SetjmpLongjmp)
if(TARGET_OS STREQUAL "AIX" AND ARCH STREQUAL "PowerPC")
   endif()
 endif()
 if(TARGET_OS STREQUAL "Darwin")
   list(REMOVE_ITEM Source 2007-04-25-weak.c)
   if(ARCH STREQUAL "PowerPC")
     list(REMOVE_ITEM Source AtomicOps.c)
   endif()
 endif()
+if(TARGET_OS STREQUAL "Windows")
+  list(APPEND LDFLAGS libcmt.lib)
+  list(REMOVE_ITEM Source 2004-11-28-GlobalBoolLayout.c)
+  list(REMOVE_ITEM Source 2005-05-11-Popcount-ffs-fls.c)
+else()
+  add_subdirectory(Threads)
+endif()
 if(ARCH STREQUAL "AArch64")
   list(REMOVE_ITEM Source blockstret.c)
 endif()
 if(ARCH STREQUAL "Mips")
   add_subdirectory(Mips)
   # Only MIPS 64-bit supports 8 bytes atomic operations.
   if(NOT MIPS_IS_MIPS64_ENABLED)
     list(REMOVE_ITEM Source AtomicOps.c)

SingleSource/UnitTests/Vectorizer/gcc-loops.cpp

-#include <sys/time.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <iostream>
 #include <vector>
 #include <numeric>
 
+#ifndef _WIN32
+#include <sys/time.h>
+#include <unistd.h>
+#else
+#include <windows.h>
+void gettimeofday(struct timeval *tm, struct timezone *tz)
+{
+  FILETIME ft;
+  ULARGE_INTEGER uli;
+
+  GetSystemTimeAsFileTime(&ft);
+  uli.LowPart = ft.dwLowDateTime;
+  uli.HighPart = ft.dwHighDateTime;
+
+  // Convert to microseconds (1 microsecond = 10^-6 seconds)
+  uli.QuadPart /= 10ULL; // Divide by 10 to convert 100ns intervals to microseconds
+
+  tm->tv_sec = (long)((uli.QuadPart - 11644473600000000ULL) / 1000000ULL); // Convert to Unix timestamp
+  tm->tv_usec = (long)(uli.QuadPart % 1000000ULL);
+}
+#endif
+
 /// This test contains some of the loops from the GCC vectrorizer example page [1].
 /// Dorit Nuzman who developed the gcc vectorizer said that we can use them in our test suite.
 ///
 /// [1] - http://gcc.gnu.org/projects/tree-ssa/vectorization.html
 
 #define N 1024
 #define M 32
 #define K 4
void example1 () {
 
   for (i=0; i<256; i++){
     a[i] = b[i] + c[i];
   }
 }
 
 __attribute__((noinline))
 void example2a (int n, int x) {
-   int i;
 
-   /* feature: support for unknown loop bound  */
-   /* feature: support for loop invariants  */
    for (i=0; i<n; i++) {
-      b[i] = x;
-   }
 }
 
 __attribute__((noinline))
 void example2b (int n, int x) {
   int i = 0;
-   /* feature: general loop exit condition  */
-   /* feature: support for bitwise operations  */
    while (n--){
       a[i] = b[i]&c[i]; i++;
-   }
 }
 
 
 typedef int aint __attribute__ ((__aligned__(16)));
 __attribute__((noinline))
 void example3 (int n, aint * __restrict__ p, aint * __restrict q) {
 
-   /* feature: support for (aligned) pointer accesses.  */
    while (n--){
-      *p++ = *q++;
-   }
 }
 
 __attribute__((noinline))
 void example4a (int n, aint * __restrict__ p, aint * __restrict__ q) {
-   /* feature: support for (aligned) pointer accesses  */
-   /* feature: support for constants  */
    while (n--){
-      *p++ = *q++ + 5;
-   }
 }
 
 __attribute__((noinline))
 void example4b (int n, aint * __restrict__ p, aint * __restrict__ q) {
-   int i;
 
-   /* feature: support for read accesses with a compile time known misalignment  */
    for (i=0; i<n; i++){
       a[i] = b[i+1] + c[i+3];
-   }
 }
 
 __attribute__((noinline))
 void example4c (int n, aint * __restrict__ p, aint * __restrict__ q) {
-   int i;
-    const int MAX = 4;
-   /* feature: support for if-conversion  */
    for (i=0; i<n; i++){
-      int j = a[i];
-      b[i] = (j > MAX ? MAX : 0);
-   }
 }
 
 __attribute__((noinline))
 void  example5 (int n, struct A *s) {
   int i;
   for (i = 0; i < n; i++) {
     /* feature: support for alignable struct access  */
     s->ca[i] = 5;
   }
 }
 
 __attribute__((noinline))
 void  example7 (int x) {
-   int i;
 
-   /* feature: support for read accesses with an unknown misalignment  */
    for (i=0; i<N; i++){
       a[i] = b[i+x];
-   }
 }
 
 int G[M][N];
 __attribute__((noinline))
 void example8 (int x) {
    int i,j;
 
-   /* feature: support for multidimensional arrays  */
    for (i=0; i<M; i++) {
      for (j=0; j<N; j++) {
-       G[i][j] = x;
-     }
-   }
 }
 
 
 __attribute__((noinline))
 void example9 (unsigned *ret) {
   int i;
 
   /* feature: support summation reduction.
      note: in case of floats use -funsafe-math-optimizations  */
   unsigned int diff = 0;
   for (i = 0; i < N; i++) {
     diff += (ub[i] - uc[i]);
   }
 
   *ret = diff;
 }
 
 
 /* feature: support data-types of different sizes.
-   Currently only a single vector-size per target is supported; 
-   it can accommodate n elements such that n = vector-size/element-size 
-   (e.g, 4 ints, 8 shorts, or 16 chars for a vector of size 16 bytes). 
-   A combination of data-types of different sizes in the same loop 
+   Currently only a single vector-size per target is supported;
+   it can accommodate n elements such that n = vector-size/element-size
+   (e.g, 4 ints, 8 shorts, or 16 chars for a vector of size 16 bytes).
+   A combination of data-types of different sizes in the same loop
    requires special handling. This support is now present in mainline,
    and also includes support for type conversions.  */
 __attribute__((noinline))
 void example10a(short *__restrict__ sa, short *__restrict__ sb, short *__restrict__ sc, int* __restrict__ ia, int* __restrict__ ib, int* __restrict__ ic) {
   int i;
   for (i = 0; i < N; i++) {
     ia[i] = ib[i] + ic[i];
     sa[i] = sb[i] + sc[i];
   }
 }
 
 __attribute__((noinline))
 void example10b(short *__restrict__ sa, short *__restrict__ sb, short *__restrict__ sc, int* __restrict__ ia, int* __restrict__ ib, int* __restrict__ ic) {
   int i;
   for (i = 0; i < N; i++) {
     ia[i] = (int) sb[i];
   }
 }
 
 /* feature: support strided accesses - the data elements
    that are to be operated upon in parallel are not consecutive - they
    are accessed with a stride > 1 (in the example, the stride is 2):  */
 __attribute__((noinline))
 void example11() {
-   int i;
   for (i = 0; i < N/2; i++){
     a[i] = b[2*i+1] * c[2*i+1] - b[2*i] * c[2*i];
     d[i] = b[2*i] * c[2*i+1] + b[2*i+1] * c[2*i];
   }
 }
 
 
 __attribute__((noinline))

 
 
 __attribute__((noinline))
 void example25 (void)
 {
   int i;
   char x, y;
   for (i = 0; i < N; i++)
-    {
-      x = (da[i] < db[i]);
-      y = (dc[i] < dd[i]);
-      dj[i] = x & y;
-    }
 }
 
 void init_memory(void *start, void* end) {
   unsigned char state = 1;
   while (start != end) {
     state *= 7; state ^= 0x27; state += 1;
     *((unsigned char*)start) = state;
     start = ((char*)start) + 1;

 
 // Warmup and then measure.
 #define BENCH(NAME, RUN_LINE, ITER, DIGEST_LINE) {\
   RUN_LINE;\
   Timer atimer(NAME, print_times);\
   for (int i=0; i < (ITER); ++i) RUN_LINE;\
   unsigned r = DIGEST_LINE;\
   results.push_back(r);\
   }
 
 int main(int argc,char* argv[]){
 
   bool print_times = argc > 1;
 
   std::vector<unsigned> results;
   unsigned dummy = 0;
 #ifdef SMALL_PROBLEM_SIZE

cmake/modules/HandleCompilerRT.cmake

+# Find the path to compiler-rt builtins library for the current target and
+# and return it in `variable`.
+function(find_compiler_rt_library variable)
+  set(target "${CMAKE_CXX_COMPILER_TARGET}")
+  if(NOT DEFINED COMPILER_RT_LIBRARY_builtins_${target} OR NOT ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
+    # If the cache variable is not defined, invoke Clang and then
+    # set it with cache_compiler_rt_library.
+    set(clang_command ${CMAKE_CXX_COMPILER} "${ARG_FLAGS}")
+    if(target)
+      list(APPEND clang_command "--target=${target}")
+    endif()
+    get_property(cxx_flags CACHE CMAKE_CXX_FLAGS PROPERTY VALUE)
+    string(REPLACE " " ";" cxx_flags "${cxx_flags}")
+    list(APPEND clang_command ${cxx_flags})
+    set(cmd_prefix "")
+    if(MSVC)
+      set(cmd_prefix "/clang:")
+    endif()
+    execute_process(
+      COMMAND ${clang_command} "${cmd_prefix}--rtlib=compiler-rt" "${cmd_prefix}-print-libgcc-file-name"
+      RESULT_VARIABLE had_error
+      OUTPUT_VARIABLE library_file
+    )
+    string(STRIP "${library_file}" library_file)
+    file(TO_CMAKE_PATH "${library_file}" library_file)
+    get_filename_component(basename ${library_file} NAME)
+    if(EXISTS "${library_file}" AND (basename MATCHES ".*clang_rt\.([a-z0-9_\-]+)\.(a|lib)"))
+      message(STATUS "Found compiler-rt library: ${basename}")
+      set(COMPILER_RT_LIBRARY_builtins_${target} "${basename}" CACHE INTERNAL
+        "compiler-rt library for ${target}")
+    else()
+      message(STATUS "Failed to find compiler-rt library for ${target}")
+      set(COMPILER_RT_LIBRARY_builtins_${target} "NOTFOUND" CACHE INTERNAL
+          "compiler-rt library for ${target}")
+    endif()
+  endif()
+
+  if(NOT COMPILER_RT_LIBRARY_builtins_${target})
+    set(${variable} "NOTFOUND" PARENT_SCOPE)
+  else()
+    set(${variable} "${COMPILER_RT_LIBRARY_builtins_${target}}" PARENT_SCOPE)
+  endif()
+endfunction()