diff --git a/CMakeLists.txt b/CMakeLists.txt
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -244,6 +244,7 @@
 if(NOT DEFINED X86CPU_ARCH AND ARCH STREQUAL "x86")
   include(DetectArchitecture)
   detect_x86_cpu_architecture(X86CPU_ARCH)
+  detect_x86_feature(sse2 HAVE_X86_SSE2_INSTRUCTIONS)
 endif()
 if(NOT DEFINED ENDIAN)
   include(TestBigEndian)
diff --git a/SingleSource/UnitTests/Vectorizer/CMakeLists.txt b/SingleSource/UnitTests/Vectorizer/CMakeLists.txt
--- a/SingleSource/UnitTests/Vectorizer/CMakeLists.txt
+++ b/SingleSource/UnitTests/Vectorizer/CMakeLists.txt
@@ -1,2 +1,10 @@
+# currently libmvec vectorizer only has support for x86 SSE2 -
+# no need to run test if code doesn't get vectorized
+if(HAVE_X86_SSE2_INSTRUCTIONS)
+  check_c_compiler_flag(-fveclib=libmvec COMPILER_HAS_FVECLIB_LIBMVEC_FLAG)
+  if(COMPILER_HAS_FVECLIB_LIBMVEC_FLAG)
+    add_subdirectory(Libmvec)
+  endif()
+endif()
 llvm_singlesource()
 set_property(TARGET runtime-checks PROPERTY CXX_STANDARD 17)
diff --git a/SingleSource/UnitTests/Vectorizer/Libmvec/CMakeLists.txt b/SingleSource/UnitTests/Vectorizer/Libmvec/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/SingleSource/UnitTests/Vectorizer/Libmvec/CMakeLists.txt
@@ -0,0 +1,3 @@
+list(APPEND LDFLAGS -lm -fveclib=libmvec)
+list(APPEND CFLAGS -fveclib=libmvec -O2 -march=native)
+llvm_singlesource(PREFIX "Vectorizer-Libmvec-")
diff --git a/SingleSource/UnitTests/Vectorizer/Libmvec/sincos.c b/SingleSource/UnitTests/Vectorizer/Libmvec/sincos.c
new file mode 100644
--- /dev/null
+++ b/SingleSource/UnitTests/Vectorizer/Libmvec/sincos.c
@@ -0,0 +1,115 @@
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <math.h>
+
+// inner loop vectorization with linear access
+void sincos_arr(double* sines, double* cosines, double* phases, int size) {
+    for (int i=0; i<size; i++) {
+        sincos(phases[i], sines+i, cosines+i);
+    }
+}
+
+// outer loop vectorization with linear access
+void sincos_arr_nested(double* sines, double* cosines, double* phases, int size, int nests) {
+    for (int i=0; i<size; i++) {
+        sincos(phases[i], sines+i, cosines+i);
+        for (int k=0; k<nests; k++) {
+            sincos(sines[i]+cosines[i], sines+i, cosines+i);
+        }
+    }
+}
+
+// inner loop vectorization with nonlinear access
+void sincos_arr_scrambled(double* sines, double* cosines, double* phases, int* indices, int size) {
+    for (int i=0; i<size; i++) {
+        int j = indices[i];
+        sincos(phases[j], sines+j, cosines+j);
+    }
+}
+
+// outer loop vectorization with nonlinear access
+void sincos_arr_scrambled_nested(double* sines, double* cosines, double* phases, int* indices, int size, int nests) {
+    for (int i=0; i<size; i++) {
+        int j = indices[i];
+        sincos(phases[j], sines+j, cosines+j);
+        for (int k=0; k<nests; k++) {
+            sincos(sines[j]+cosines[j], sines+j, cosines+j);
+        }
+    }
+}
+
+// returns true (=failure) iff ULP error is larger than max_ulp_err, with a simplified definition of ULP
+int check_ULP(double arg, double val, double ref, double max_ulp_err, int index, const char* msg1, const char* msg2)
+{
+    double ulp = 0.5 * (nextafter(ref, INFINITY) - nextafter(ref, -INFINITY));
+    if (fabs(val - ref) > max_ulp_err * ulp) {
+        printf("%s,%s FAILED at %d: argument %g, value %g, reference %g, difference %g, (%g ULP).\n",
+               msg1, msg2, index, arg, val, ref, (val-ref), fabs(val-ref)/ulp);
+        return 1;
+    }
+    return 0;
+}
+
+int check_arr(double* sines, double* coses, double* phases, int* indices, int size, int nests, double max_ulp_err, const char* msg)
+{
+    int fail = 0;
+
+    for (int i = 0; i < size; i++) {
+        int j = indices ? indices[i] : i;
+        double ref_sin = sin(phases[j]);
+        double ref_cos = cos(phases[j]);
+        for (int k=0; k<nests; k++) {
+                double arg = ref_sin+ref_cos;
+                ref_sin = sin(arg);
+                ref_cos = cos(arg);
+            }
+        fail |= check_ULP(phases[j], sines[j], ref_sin, max_ulp_err, i, msg, "sin");
+        fail |= check_ULP(phases[j], coses[j], ref_cos, max_ulp_err, i, msg, "cos");
+    }
+    return fail;
+}
+
+int main(int argc, char *argv[])
+{
+    argc |= 1; // ensure argc is odd for better test coverage
+    const int loops = argc;
+    const int N = 26 + argc;
+    const int nests = 4 + argc;
+    int indices[N];
+    double phases[N], sines[N], coses[N];
+    int fail = 0;
+    const double MAX_ULP_ERR_NESTED = 64;
+    const double MAX_ULP_ERR = 16;
+
+    for (int l=0; l<loops; l++) {
+        // test with linear access:
+        for (int i = 0; i < N; i++) {
+            phases[i] = i;
+            indices[i] = i;
+            sines[i] = 0.0 / 0.0;
+            coses[i] = 0.0 / 0.0;
+        }
+        sincos_arr(sines, coses, phases, N);
+        fail |= check_arr(sines, coses, phases, NULL, N, 0, MAX_ULP_ERR, "sincos_arr");
+        sincos_arr_nested(sines, coses, phases, N, nests);
+        fail |= check_arr(sines, coses, phases, NULL, N, nests, MAX_ULP_ERR_NESTED, "sincos_arr_nested");
+
+        // test with nonlinear access:
+        for (int i = 0; i < N; i++) {
+            indices[i] = (i < 2) ? 1 : (indices[i - 2] + indices[i - 1]) % N;
+            sines[i] = 0.0 / 0.0;
+            coses[i] = 0.0 / 0.0;
+        }
+        sincos_arr_scrambled(sines, coses, phases, indices, N);
+        fail |= check_arr(sines, coses, phases, indices, N, 0, MAX_ULP_ERR, "sincos_arr_scrambled");
+        sincos_arr_scrambled_nested(sines, coses, phases, indices, N, nests);
+        fail |= check_arr(sines, coses, phases, indices, N, nests, MAX_ULP_ERR_NESTED, "sincos_arr_scrambled_nested");
+    }
+    if (fail) {
+        printf("FAILED!\n");
+    } else {
+        printf("Passed.\n");
+    }
+    return fail;
+}
diff --git a/SingleSource/UnitTests/Vectorizer/Libmvec/sincos.reference_output b/SingleSource/UnitTests/Vectorizer/Libmvec/sincos.reference_output
new file mode 100644
--- /dev/null
+++ b/SingleSource/UnitTests/Vectorizer/Libmvec/sincos.reference_output
@@ -0,0 +1,2 @@
+Passed.
+exit 0
diff --git a/cmake/modules/DetectArchitecture.cmake b/cmake/modules/DetectArchitecture.cmake
--- a/cmake/modules/DetectArchitecture.cmake
+++ b/cmake/modules/DetectArchitecture.cmake
@@ -60,3 +60,31 @@
   endif()
 
 endfunction(detect_x86_cpu_architecture)
+
+#
+# Performs a try_run to check cpu feature flag of target
+#
+
+function(detect_x86_feature feature variable)
+  try_run(HAVE_RUN_CPU_FEATURE_${variable} HAVE_COMPILE_CPU_FEATURE_${variable}
+          ${CMAKE_BINARY_DIR}
+          ${CMAKE_SOURCE_DIR}/cmake/modules/DetectX86FeatureFlag.c
+          COMPILE_DEFINITIONS -DFEATURE_FLAG=${feature}
+          COMPILE_OUTPUT_VARIABLE COMP_OUTPUT
+          RUN_OUTPUT_VARIABLE RUN_OUTPUT)
+
+  if(HAVE_COMPILE_CPU_FEATURE_${variable} AND NOT (HAVE_RUN_CPU_FEATURE_${variable} STREQUAL  FAILED_TO_RUN))
+    if(RUN_OUTPUT)
+      message(STATUS "Check target cpu feature ${feature}: ${RUN_OUTPUT}")
+      set(${variable} ${RUN_OUTPUT} PARENT_SCOPE)
+    else()
+      message(SEND_ERROR "Could not detect target cpu feature ${feature}!")
+    endif()
+  else()
+    message(STATUS "Check target system for feature ${feature} - failed")
+    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+            "Determining the system cpu feature failed with the following output:\n${COMP_OUTPUT}\n${RUN_OUTPUT}")
+    set(${variable} PARENT_SCOPE)
+  endif()
+
+endfunction(detect_x86_feature)
diff --git a/cmake/modules/DetectX86FeatureFlag.c b/cmake/modules/DetectX86FeatureFlag.c
new file mode 100644
--- /dev/null
+++ b/cmake/modules/DetectX86FeatureFlag.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+#define xstr(s) str(s)
+#define str(s) #s
+
+int main(void) {
+  __builtin_cpu_init();
+  if (__builtin_cpu_supports(xstr(FEATURE_FLAG))) {
+      printf("YES");
+  } else {
+      printf("NO");
+  }
+  return 0;
+}