From 1c192f22656e890e3da439ab44ff403f659f3c1b Mon Sep 17 00:00:00 2001 From: liujia178 Date: Tue, 19 Dec 2023 19:02:57 +0800 Subject: [PATCH] add linux arm llvmts shell Signed-off-by: liujia178 --- LLVMTS/D102861.diff | 2440 +++++++++++++++++++++++ llvm_test_script/generate_config.py | 1 + llvm_test_script/run_aarch64_O2-test.sh | 113 ++ llvm_test_script/run_aarch64_docker.sh | 198 ++ llvm_test_script/run_aarch64_test.sh | 110 + 5 files changed, 2862 insertions(+) create mode 100644 LLVMTS/D102861.diff create mode 100644 llvm_test_script/run_aarch64_O2-test.sh create mode 100644 llvm_test_script/run_aarch64_docker.sh create mode 100644 llvm_test_script/run_aarch64_test.sh diff --git a/LLVMTS/D102861.diff b/LLVMTS/D102861.diff new file mode 100644 index 0000000..746975e --- /dev/null +++ b/LLVMTS/D102861.diff @@ -0,0 +1,2440 @@ +diff --git a/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt b/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt +--- a/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt ++++ b/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt +@@ -2,6 +2,10 @@ + list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS}) + list(APPEND LDFLAGS -lm) + ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_test_verify_hash_program_output(bilateralFilterOutput.txt) + llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR} + ${FPCMP} bilateralFilter.reference_output bilateralFilterOutput.txt +diff --git a/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt b/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt +--- a/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt ++++ b/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt +@@ -3,6 +3,10 @@ + list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS}) + list(APPEND LDFLAGS -lm) + ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_test_verify_hash_program_output(boxBlurOutput.txt) + llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR} + ${FPCMP} boxBlur.reference_output boxBlurOutput.txt +diff --git a/MultiSource/Applications/oggenc/CMakeLists.txt b/MultiSource/Applications/oggenc/CMakeLists.txt +--- a/MultiSource/Applications/oggenc/CMakeLists.txt ++++ b/MultiSource/Applications/oggenc/CMakeLists.txt +@@ -1,4 +1,8 @@ + list(APPEND CFLAGS -fno-strict-aliasing) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + list(APPEND LDFLAGS -lm) + set(RUN_OPTIONS -Q -s 901820 - < tune) + llvm_multisource(oggenc) +diff --git a/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt b/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt +--- a/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt ++++ b/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt +@@ -1,2 +1,6 @@ + set(RUN_OPTIONS -n 64 -t 1000) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_multisource(CLAMR) +diff --git a/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt b/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt +--- a/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt ++++ b/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt +@@ -1,4 +1,8 @@ + list(APPEND CXXFLAGS -DREDSTORM) # -DREDSTORM for mkdir ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + list(APPEND LDFLAGS -lm) + set(RUN_OPTIONS 50 50 50) + llvm_multisource(HPCCG) +diff --git a/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt b/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt +--- a/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt ++++ b/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt +@@ -6,6 +6,10 @@ + if(CMAKE_SYSTEM_NAME STREQUAL "AIX") + list(APPEND CXXFLAGS -D_XOPEN_SOURCE=700 -DUseTimes) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + list(APPEND LDFLAGS -lm) + set(RUN_OPTIONS -nx 64 -ny 64 -nz 64) + llvm_multisource(miniFE) +diff --git a/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt b/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt +--- a/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt ++++ b/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt +@@ -1,6 +1,10 @@ + list(APPEND LDFLAGS -lm) + set(FP_ABSTOLERANCE 0.00001) + list(APPEND CFLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/../Common) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_multisource(srad + main.c + sradKernel.c +diff --git a/SingleSource/Benchmarks/Linpack/CMakeLists.txt b/SingleSource/Benchmarks/Linpack/CMakeLists.txt +--- a/SingleSource/Benchmarks/Linpack/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Linpack/CMakeLists.txt +@@ -1,3 +1,7 @@ + list(APPEND LDFLAGS -lm) + set(FP_TOLERANCE 0.0001) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt b/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt +--- a/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt +@@ -1,4 +1,8 @@ + list(APPEND LDFLAGS -lm) + set(FP_ABSTOLERANCE 0.01) + set(HASH_PROGRAM_OUTPUT 1) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c b/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c +--- a/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c ++++ b/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c +@@ -121,6 +121,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_correlation_StrictFP(int m, int n, + DATA_TYPE float_n, +@@ -206,6 +210,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -217,7 +222,9 @@ + DATA_TYPE float_n; + POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); + POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(symmat_StrictFP,DATA_TYPE,M,M,m,m); ++#endif + POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); + POLYBENCH_1D_ARRAY_DECL(stddev,DATA_TYPE,M,m); + +@@ -238,6 +245,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); ++#else + init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); + kernel_correlation (m, n, float_n, + POLYBENCH_ARRAY(data), +@@ -250,11 +262,14 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(data); + POLYBENCH_FREE_ARRAY(symmat); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(symmat_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(mean); + POLYBENCH_FREE_ARRAY(stddev); + +diff --git a/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c b/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c +--- a/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c ++++ b/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c +@@ -93,6 +93,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_covariance_StrictFP(int m, int n, + DATA_TYPE float_n, +@@ -152,6 +156,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -163,7 +168,9 @@ + DATA_TYPE float_n; + POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); + POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(symmat_StrictFP,DATA_TYPE,M,M,m,m); ++#endif + POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); + + +@@ -183,6 +190,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); ++#else + init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); + kernel_covariance (m, n, float_n, + POLYBENCH_ARRAY(data), +@@ -194,11 +206,14 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(data); + POLYBENCH_FREE_ARRAY(symmat); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(symmat_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(mean); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c +@@ -26,8 +26,11 @@ + DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nl), + DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj), + DATA_TYPE POLYBENCH_2D(C,NL,NJ,nl,nj), +- DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl), +- DATA_TYPE POLYBENCH_2D(D_StrictFP,NI,NL,ni,nl)) ++ DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl) ++#if !FMA_DISABLED ++ , DATA_TYPE POLYBENCH_2D(D_StrictFP,NI,NL,ni,nl) ++#endif ++ ) + { + #pragma STDC FP_CONTRACT OFF + int i, j; +@@ -45,7 +48,10 @@ + C[i][j] = ((DATA_TYPE) i*(j+3)) / nl; + for (i = 0; i < ni; i++) + for (j = 0; j < nl; j++) +- D_StrictFP[i][j] = D[i][j] = ((DATA_TYPE) i*(j+2)) / nk; ++#if !FMA_DISABLED ++ D_StrictFP[i][j] = ++#endif ++ D[i][j] = ((DATA_TYPE) i*(j+2)) / nk; + } + + +@@ -101,6 +107,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_2mm_StrictFP(int ni, int nj, int nk, int nl, + DATA_TYPE alpha, +@@ -155,6 +165,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -172,15 +183,20 @@ + POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj); + POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NL,NJ,nl,nj); + POLYBENCH_2D_ARRAY_DECL(D,DATA_TYPE,NI,NL,ni,nl); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(D_StrictFP,DATA_TYPE,NI,NL,ni,nl); ++#endif + + /* Initialize array(s). */ + init_array (ni, nj, nk, nl, &alpha, &beta, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B), + POLYBENCH_ARRAY(C), +- POLYBENCH_ARRAY(D), +- POLYBENCH_ARRAY(D_StrictFP)); ++ POLYBENCH_ARRAY(D) ++#if !FMA_DISABLED ++ , POLYBENCH_ARRAY(D_StrictFP) ++#endif ++ ); + + /* Start timer. */ + polybench_start_instruments; +@@ -198,6 +214,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(D))); ++#else + kernel_2mm_StrictFP(ni, nj, nk, nl, + alpha, beta, + POLYBENCH_ARRAY(tmp), +@@ -212,6 +233,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(D_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(tmp); +@@ -219,7 +241,9 @@ + POLYBENCH_FREE_ARRAY(B); + POLYBENCH_FREE_ARRAY(C); + POLYBENCH_FREE_ARRAY(D); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(D_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt +@@ -5,4 +5,7 @@ + endif() + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c +@@ -105,6 +105,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_3mm_StrictFP(int ni, int nj, int nk, int nl, int nm, + DATA_TYPE POLYBENCH_2D(E,NI,NJ,ni,nj), +@@ -167,6 +171,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -185,7 +190,9 @@ + POLYBENCH_2D_ARRAY_DECL(C, DATA_TYPE, NJ, NM, nj, nm); + POLYBENCH_2D_ARRAY_DECL(D, DATA_TYPE, NM, NL, nm, nl); + POLYBENCH_2D_ARRAY_DECL(G, DATA_TYPE, NI, NL, ni, nl); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(G_StrictFP, DATA_TYPE, NI, NL, ni, nl); ++#endif + + /* Initialize array(s). */ + init_array (ni, nj, nk, nl, nm, +@@ -211,6 +218,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G))); ++#else + kernel_3mm_StrictFP(ni, nj, nk, nl, nm, + POLYBENCH_ARRAY(E), + POLYBENCH_ARRAY(A), +@@ -225,6 +237,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(E); +@@ -234,7 +247,9 @@ + POLYBENCH_FREE_ARRAY(C); + POLYBENCH_FREE_ARRAY(D); + POLYBENCH_FREE_ARRAY(G); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(G_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt +@@ -5,4 +5,7 @@ + endif() + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt +@@ -2,4 +2,8 @@ + list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c +@@ -77,6 +77,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_atax_StrictFP(int nx, int ny, + DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny), +@@ -121,6 +125,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -132,7 +137,9 @@ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny); + POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, NY, ny); + POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, NY, ny); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(y_StrictFP, DATA_TYPE, NY, ny); ++#endif + POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, NX, nx); + + /* Initialize array(s). */ +@@ -152,6 +159,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y))); ++#else + kernel_atax_StrictFP (nx, ny, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(x), +@@ -163,12 +175,15 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(x); + POLYBENCH_FREE_ARRAY(y); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(y_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(tmp); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt +@@ -2,4 +2,8 @@ + list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c +@@ -90,6 +90,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_bicg_StrictFP(int nx, int ny, + DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny), +@@ -137,6 +141,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -150,8 +155,10 @@ + POLYBENCH_1D_ARRAY_DECL(q, DATA_TYPE, NX, nx); + POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, NY, ny); + POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, NX, nx); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(s_StrictFP, DATA_TYPE, NY, ny); + POLYBENCH_1D_ARRAY_DECL(q_StrictFP, DATA_TYPE, NX, nx); ++#endif + + /* Initialize array(s). */ + init_array (nx, ny, +@@ -174,6 +181,12 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(s), ++ POLYBENCH_ARRAY(q))); ++#else + kernel_bicg_StrictFP(nx, ny, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(s_StrictFP), +@@ -190,6 +203,7 @@ + by the function call in argument. */ + polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(s_StrictFP), + POLYBENCH_ARRAY(q_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); +@@ -197,8 +211,10 @@ + POLYBENCH_FREE_ARRAY(q); + POLYBENCH_FREE_ARRAY(p); + POLYBENCH_FREE_ARRAY(r); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(s_StrictFP); + POLYBENCH_FREE_ARRAY(q_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c +@@ -22,8 +22,11 @@ + static + void init_array(int n, + DATA_TYPE POLYBENCH_1D(p,N,n), +- DATA_TYPE POLYBENCH_2D(A,N,N,n,n), +- DATA_TYPE POLYBENCH_2D(A_StrictFP,N,N,n,n)) ++ DATA_TYPE POLYBENCH_2D(A,N,N,n,n) ++#if !FMA_DISABLED ++ , DATA_TYPE POLYBENCH_2D(A_StrictFP,N,N,n,n) ++#endif ++ ) + { + #pragma STDC FP_CONTRACT OFF + int i, j; +@@ -43,7 +46,10 @@ + { + p[i] = i + n; + for (j = 0; j < n; j++) +- A_StrictFP[i][j] = A[i][j] = j + n; ++#if !FMA_DISABLED ++ A_StrictFP[i][j] = ++#endif ++ A[i][j] = j + n; + } + } + +@@ -104,6 +110,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_cholesky_StrictFP(int n, + DATA_TYPE POLYBENCH_1D(p,N,n), +@@ -160,6 +170,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -169,12 +180,17 @@ + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); + POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); ++#endif + + + /* Initialize array(s). */ +- init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A), +- POLYBENCH_ARRAY(A_StrictFP)); ++ init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A) ++#if !FMA_DISABLED ++ , POLYBENCH_ARRAY(A_StrictFP) ++#endif ++ ); + + /* Start timer. */ + polybench_start_instruments; +@@ -186,6 +202,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); ++#else + kernel_cholesky_StrictFP(n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A_StrictFP)); + if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP))) + return 1; +@@ -193,10 +214,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(A_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(p); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c +@@ -21,8 +21,10 @@ + /* Array initialization. */ + static + void init_array(int nr, int nq, int np, +- DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np), +- DATA_TYPE POLYBENCH_3D(A_StrictFP,NR,NQ,NP,nr,nq,np), ++ DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np) ++#if !FMA_DISABLED ++ , DATA_TYPE POLYBENCH_3D(A_StrictFP,NR,NQ,NP,nr,nq,np), ++#endif + DATA_TYPE POLYBENCH_2D(C4,NP,NP,np,np)) + { + #pragma STDC FP_CONTRACT OFF +@@ -31,7 +33,10 @@ + for (i = 0; i < nr; i++) + for (j = 0; j < nq; j++) + for (k = 0; k < np; k++) +- A_StrictFP[i][j][k] = A[i][j][k] = ((DATA_TYPE) i*j + k) / np; ++#if !FMA_DISABLED ++ A_StrictFP[i][j][k] = ++#endif ++ A[i][j][k] = ((DATA_TYPE) i*j + k) / np; + for (i = 0; i < np; i++) + for (j = 0; j < np; j++) + C4[i][j] = ((DATA_TYPE) i*j) / np; +@@ -82,6 +87,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_doitgen_StrictFP(int nr, int nq, int np, + DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np), +@@ -127,6 +136,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -137,14 +147,18 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_3D_ARRAY_DECL(A,DATA_TYPE,NR,NQ,NP,nr,nq,np); ++#if !FMA_DISABLED + POLYBENCH_3D_ARRAY_DECL(A_StrictFP,DATA_TYPE,NR,NQ,NP,nr,nq,np); ++#endif + POLYBENCH_3D_ARRAY_DECL(sum,DATA_TYPE,NR,NQ,NP,nr,nq,np); + POLYBENCH_2D_ARRAY_DECL(C4,DATA_TYPE,NP,NP,np,np); + + /* Initialize array(s). */ + init_array (nr, nq, np, + POLYBENCH_ARRAY(A), ++#if !FMA_DISABLED + POLYBENCH_ARRAY(A_StrictFP), ++#endif + POLYBENCH_ARRAY(C4)); + + /* Start timer. */ +@@ -160,6 +174,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A))); ++#else + kernel_doitgen_StrictFP(nr, nq, np, + POLYBENCH_ARRAY(A_StrictFP), + POLYBENCH_ARRAY(C4), +@@ -171,10 +190,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(A_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(sum); + POLYBENCH_FREE_ARRAY(C4); + +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c +@@ -24,7 +24,9 @@ + DATA_TYPE *alpha, + DATA_TYPE *beta, + DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NJ,ni,nj), ++#endif + DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk), + DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj)) + { +@@ -35,7 +37,10 @@ + *beta = 2123; + for (i = 0; i < ni; i++) + for (j = 0; j < nj; j++) +- C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; ++#if !FMA_DISABLED ++ C_StrictFP[i][j] = ++#endif ++ C[i][j] = ((DATA_TYPE) i*j) / ni; + for (i = 0; i < ni; i++) + for (j = 0; j < nk; j++) + A[i][j] = ((DATA_TYPE) i*j) / ni; +@@ -88,6 +93,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_gemm_StrictFP(int ni, int nj, int nk, + DATA_TYPE alpha, +@@ -133,6 +142,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -145,14 +155,18 @@ + DATA_TYPE alpha; + DATA_TYPE beta; + POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NJ,ni,nj); ++#endif + POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NK,ni,nk); + POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj); + + /* Initialize array(s). */ + init_array (ni, nj, nk, &alpha, &beta, + POLYBENCH_ARRAY(C), ++#if !FMA_DISABLED + POLYBENCH_ARRAY(C_StrictFP), ++#endif + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B)); + +@@ -170,6 +184,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); ++#else + kernel_gemm_StrictFP(ni, nj, nk, + alpha, beta, + POLYBENCH_ARRAY(C_StrictFP), +@@ -181,10 +200,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(C); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(C_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(B); + +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt +@@ -2,4 +2,8 @@ + list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c +@@ -29,7 +29,9 @@ + DATA_TYPE POLYBENCH_1D(u2,N,n), + DATA_TYPE POLYBENCH_1D(v2,N,n), + DATA_TYPE POLYBENCH_1D(w,N,n), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_1D(w_StrictFP,N,n), ++#endif + DATA_TYPE POLYBENCH_1D(y,N,n), + DATA_TYPE POLYBENCH_1D(z,N,n)) + { +@@ -47,7 +49,10 @@ + v2[i] = (i+1)/n/6.0; + y[i] = (i+1)/n/8.0; + z[i] = (i+1)/n/9.0; +- w_StrictFP[i] = w[i] = 0.0; ++ w[i] = 0.0; ++#if !FMA_DISABLED ++ w_StrictFP[i] = 0.0; ++#endif + for (j = 0; j < n; j++) + A[i][j] = ((DATA_TYPE) i*j) / n; + } +@@ -109,6 +114,10 @@ + #pragma endscop + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_gemver_StrictFP(int n, + DATA_TYPE alpha, +@@ -167,6 +176,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -183,7 +193,9 @@ + POLYBENCH_1D_ARRAY_DECL(u2, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(v2, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(w, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(w_StrictFP, DATA_TYPE, N, n); ++#endif + POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(z, DATA_TYPE, N, n); +@@ -197,7 +209,9 @@ + POLYBENCH_ARRAY(u2), + POLYBENCH_ARRAY(v2), + POLYBENCH_ARRAY(w), ++#if !FMA_DISABLED + POLYBENCH_ARRAY(w_StrictFP), ++#endif + POLYBENCH_ARRAY(y), + POLYBENCH_ARRAY(z)); + +@@ -221,6 +235,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(w))); ++#else + kernel_gemver_StrictFP(n, alpha, beta, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(A_tmp), +@@ -238,6 +257,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(w_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); +@@ -247,7 +267,9 @@ + POLYBENCH_FREE_ARRAY(u2); + POLYBENCH_FREE_ARRAY(v2); + POLYBENCH_FREE_ARRAY(w); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(w_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(x); + POLYBENCH_FREE_ARRAY(y); + POLYBENCH_FREE_ARRAY(z); +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c +@@ -90,6 +90,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_gesummv_StrictFP(int n, + DATA_TYPE alpha, +@@ -138,6 +142,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -152,7 +157,9 @@ + POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(y_StrictFP, DATA_TYPE, N, n); ++#endif + + + /* Initialize array(s). */ +@@ -176,6 +183,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(y))); ++#else + kernel_gesummv_StrictFP(n, alpha, beta, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B), +@@ -188,6 +200,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(y_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c +@@ -23,8 +23,10 @@ + void init_array(int n, + DATA_TYPE POLYBENCH_1D(x1,N,n), + DATA_TYPE POLYBENCH_1D(x2,N,n), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_1D(x1_StrictFP,N,n), + DATA_TYPE POLYBENCH_1D(x2_StrictFP,N,n), ++#endif + DATA_TYPE POLYBENCH_1D(y_1,N,n), + DATA_TYPE POLYBENCH_1D(y_2,N,n), + DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) +@@ -34,8 +36,14 @@ + + for (i = 0; i < n; i++) + { +- x1_StrictFP[i] = x1[i] = ((DATA_TYPE) i) / n; +- x2_StrictFP[i] = x2[i] = ((DATA_TYPE) i + 1) / n; ++#if !FMA_DISABLED ++ x1_StrictFP[i] = ++#endif ++ x1[i] = ((DATA_TYPE) i) / n; ++#if !FMA_DISABLED ++ x2_StrictFP[i] = ++#endif ++ x2[i] = ((DATA_TYPE) i + 1) / n; + y_1[i] = ((DATA_TYPE) i + 3) / n; + y_2[i] = ((DATA_TYPE) i + 4) / n; + for (j = 0; j < n; j++) +@@ -88,6 +96,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_mvt_StrictFP(int n, + DATA_TYPE POLYBENCH_1D(x1,N,n), +@@ -129,6 +141,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -139,8 +152,10 @@ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); + POLYBENCH_1D_ARRAY_DECL(x1, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(x2, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(x1_StrictFP, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(x2_StrictFP, DATA_TYPE, N, n); ++#endif + POLYBENCH_1D_ARRAY_DECL(y_1, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(y_2, DATA_TYPE, N, n); + +@@ -149,8 +164,10 @@ + init_array (n, + POLYBENCH_ARRAY(x1), + POLYBENCH_ARRAY(x2), ++#if !FMA_DISABLED + POLYBENCH_ARRAY(x1_StrictFP), + POLYBENCH_ARRAY(x2_StrictFP), ++#endif + POLYBENCH_ARRAY(y_1), + POLYBENCH_ARRAY(y_2), + POLYBENCH_ARRAY(A)); +@@ -170,6 +187,12 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x1), ++ POLYBENCH_ARRAY(x2))); ++#else + kernel_mvt_StrictFP(n, + POLYBENCH_ARRAY(x1_StrictFP), + POLYBENCH_ARRAY(x2_StrictFP), +@@ -185,13 +208,16 @@ + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x1_StrictFP), + POLYBENCH_ARRAY(x2_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(x1); + POLYBENCH_FREE_ARRAY(x2); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(x1_StrictFP); + POLYBENCH_FREE_ARRAY(x2_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(y_1); + POLYBENCH_FREE_ARRAY(y_2); + +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c +@@ -24,7 +24,9 @@ + DATA_TYPE *alpha, + DATA_TYPE *beta, + DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NJ,ni,nj), ++#endif + DATA_TYPE POLYBENCH_2D(A,NJ,NJ,nj,nj), + DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) + { +@@ -35,7 +37,10 @@ + *beta = 2123; + for (i = 0; i < ni; i++) + for (j = 0; j < nj; j++) { +- C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; ++#if !FMA_DISABLED ++ C_StrictFP[i][j] = ++#endif ++ C[i][j] = ((DATA_TYPE) i*j) / ni; + B[i][j] = ((DATA_TYPE) i*j) / ni; + } + for (i = 0; i < nj; i++) +@@ -92,6 +97,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_symm_StrictFP(int ni, int nj, + DATA_TYPE alpha, +@@ -142,6 +151,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -153,14 +163,18 @@ + DATA_TYPE alpha; + DATA_TYPE beta; + POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NJ,ni,nj); ++#endif + POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NJ,NJ,nj,nj); + POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj); + + /* Initialize array(s). */ + init_array (ni, nj, &alpha, &beta, + POLYBENCH_ARRAY(C), ++#if !FMA_DISABLED + POLYBENCH_ARRAY(C_StrictFP), ++#endif + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B)); + +@@ -178,6 +192,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); ++#else + kernel_symm_StrictFP(ni, nj, + alpha, beta, + POLYBENCH_ARRAY(C_StrictFP), +@@ -189,10 +208,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(C); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(C_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(B); + +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c +@@ -24,7 +24,9 @@ + DATA_TYPE *alpha, + DATA_TYPE *beta, + DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NI,ni,ni), ++#endif + DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj), + DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) + { +@@ -40,7 +42,10 @@ + } + for (i = 0; i < ni; i++) + for (j = 0; j < ni; j++) +- C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; ++#if !FMA_DISABLED ++ C_StrictFP[i][j] = ++#endif ++ C[i][j] = ((DATA_TYPE) i*j) / ni; + } + + +@@ -90,6 +95,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_syr2k_StrictFP(int ni, int nj, + DATA_TYPE alpha, +@@ -138,6 +147,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -149,14 +159,18 @@ + DATA_TYPE alpha; + DATA_TYPE beta; + POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NI,ni,ni); ++#endif + POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); + POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj); + + /* Initialize array(s). */ + init_array (ni, nj, &alpha, &beta, + POLYBENCH_ARRAY(C), ++#if !FMA_DISABLED + POLYBENCH_ARRAY(C_StrictFP), ++#endif + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B)); + +@@ -174,6 +188,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C))); ++#else + kernel_syr2k_StrictFP(ni, nj, + alpha, beta, + POLYBENCH_ARRAY(C_StrictFP), +@@ -186,10 +205,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(C); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(C_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(B); + +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c +@@ -24,7 +24,9 @@ + DATA_TYPE *alpha, + DATA_TYPE *beta, + DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NI,ni,ni), ++#endif + DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj)) + { + #pragma STDC FP_CONTRACT OFF +@@ -37,7 +39,10 @@ + A[i][j] = ((DATA_TYPE) i*j) / ni; + for (i = 0; i < ni; i++) + for (j = 0; j < ni; j++) +- C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; ++#if !FMA_DISABLED ++ C_StrictFP[i][j] = ++#endif ++ C[i][j] = ((DATA_TYPE) i*j) / ni; + } + + +@@ -83,6 +88,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_syrk_StrictFP(int ni, int nj, + DATA_TYPE alpha, +@@ -127,6 +136,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -138,12 +148,17 @@ + DATA_TYPE alpha; + DATA_TYPE beta; + POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NI,ni,ni); ++#endif + POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); + + /* Initialize array(s). */ + init_array (ni, nj, &alpha, &beta, POLYBENCH_ARRAY(C), +- POLYBENCH_ARRAY(C_StrictFP), POLYBENCH_ARRAY(A)); ++#if !FMA_DISABLED ++ POLYBENCH_ARRAY(C_StrictFP), ++#endif ++ POLYBENCH_ARRAY(A)); + + /* Start timer. */ + polybench_start_instruments; +@@ -155,6 +170,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C))); ++#else + kernel_syrk_StrictFP(ni, nj, alpha, beta, POLYBENCH_ARRAY(C_StrictFP), + POLYBENCH_ARRAY(A)); + +@@ -164,10 +184,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(C); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(C_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(A); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt +@@ -1,5 +1,9 @@ + set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) + list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) + set(HASH_PROGRAM_OUTPUT 1) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c +@@ -23,7 +23,9 @@ + void init_array(int n, + DATA_TYPE POLYBENCH_2D(A,N,N,n,n), + DATA_TYPE POLYBENCH_1D(x,N,n), ++#if !FMA_DISABLED + DATA_TYPE POLYBENCH_1D(x_StrictFP,N,n), ++#endif + DATA_TYPE POLYBENCH_1D(c,N,n)) + { + #pragma STDC FP_CONTRACT OFF +@@ -42,7 +44,11 @@ + */ + for (i = 0; i < n; i++) + { +- c[i] = x_StrictFP[i] = x[i] = ((DATA_TYPE) i+n) / n; ++ c[i] = ++#if !FMA_DISABLED ++ x_StrictFP[i] = ++#endif ++ x[i] = ((DATA_TYPE) i+n) / n; + for (j = 0; j < n; j++) + A[i][j] = ((DATA_TYPE) i*j+n) / n; + } +@@ -88,6 +94,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_trisolv_StrictFP(int n, + DATA_TYPE POLYBENCH_2D(A,N,N,n,n), +@@ -128,6 +138,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -137,13 +148,18 @@ + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); + POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(x_StrictFP, DATA_TYPE, N, n); ++#endif + POLYBENCH_1D_ARRAY_DECL(c, DATA_TYPE, N, n); + + + /* Initialize array(s). */ + init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), +- POLYBENCH_ARRAY(x_StrictFP), POLYBENCH_ARRAY(c)); ++#if !FMA_DISABLED ++ POLYBENCH_ARRAY(x_StrictFP), ++#endif ++ POLYBENCH_ARRAY(c)); + + /* Start timer. */ + polybench_start_instruments; +@@ -155,16 +171,24 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x))); ++#else + kernel_trisolv (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x_StrictFP), POLYBENCH_ARRAY(c)); + + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(x); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(x_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(c); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c +@@ -23,8 +23,11 @@ + void init_array(int ni, + DATA_TYPE *alpha, + DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni), +- DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni), +- DATA_TYPE POLYBENCH_2D(B_StrictFP,NI,NI,ni,ni)) ++ DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni) ++#if !FMA_DISABLED ++ , DATA_TYPE POLYBENCH_2D(B_StrictFP,NI,NI,ni,ni) ++#endif ++ ) + { + #pragma STDC FP_CONTRACT OFF + int i, j; +@@ -33,7 +36,10 @@ + for (i = 0; i < ni; i++) + for (j = 0; j < ni; j++) { + A[i][j] = ((DATA_TYPE) i*j) / ni; +- B_StrictFP[i][j] = B[i][j] = ((DATA_TYPE) i*j) / ni; ++#if !FMA_DISABLED ++ B_StrictFP[i][j] = ++#endif ++ B[i][j] = ((DATA_TYPE) i*j) / ni; + } + } + +@@ -76,6 +82,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_trmm_StrictFP(int ni, + DATA_TYPE alpha, +@@ -116,6 +126,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -126,11 +137,16 @@ + DATA_TYPE alpha; + POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NI,ni,ni); + POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NI,ni,ni); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(B_StrictFP,DATA_TYPE,NI,NI,ni,ni); ++#endif + + /* Initialize array(s). */ +- init_array (ni, &alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B), +- POLYBENCH_ARRAY(B_StrictFP)); ++ init_array (ni, &alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B) ++#if !FMA_DISABLED ++ , POLYBENCH_ARRAY(B_StrictFP) ++#endif ++ ); + + /* Start timer. */ + polybench_start_instruments; +@@ -142,6 +158,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(B))); ++#else + kernel_trmm_StrictFP(ni, alpha, POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B_StrictFP)); + +@@ -151,6 +172,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(B_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c +@@ -92,6 +92,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static + void kernel_durbin_StrictFP(int n, + DATA_TYPE POLYBENCH_2D(y,N,N,n,n), +@@ -144,6 +148,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -157,7 +162,9 @@ + POLYBENCH_1D_ARRAY_DECL(beta, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, N, n); + POLYBENCH_1D_ARRAY_DECL(out, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(out_StrictFP, DATA_TYPE, N, n); ++#endif + + + /* Initialize array(s). */ +@@ -184,6 +191,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(out))); ++#else + init_array (n, + POLYBENCH_ARRAY(y), + POLYBENCH_ARRAY(sum), +@@ -205,6 +217,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(out_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(y); +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c +@@ -81,6 +81,10 @@ + *out = out_l; + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_dynprog_StrictFP(int tsteps, int length, + DATA_TYPE POLYBENCH_2D(c,LENGTH,LENGTH,length,length), +@@ -131,6 +135,7 @@ + } + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -139,7 +144,10 @@ + int tsteps = TSTEPS; + + /* Variable declaration/allocation. */ +- DATA_TYPE out, out_StrictFP; ++ DATA_TYPE out; ++#if !FMA_DISABLED ++ DATA_TYPE out_StrictFP; ++#endif + POLYBENCH_3D_ARRAY_DECL(sum_c,DATA_TYPE,LENGTH,LENGTH,LENGTH,length,length,length); + POLYBENCH_2D_ARRAY_DECL(c,DATA_TYPE,LENGTH,LENGTH,length,length); + POLYBENCH_2D_ARRAY_DECL(W,DATA_TYPE,LENGTH,LENGTH,length,length); +@@ -161,6 +169,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(out)); ++#else + init_array (length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W)); + kernel_dynprog (tsteps, length, + POLYBENCH_ARRAY(c), +@@ -174,6 +187,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(out_StrictFP)); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(sum_c); +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c +@@ -120,6 +120,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_gramschmidt_StrictFP(int ni, int nj, + DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj), +@@ -174,6 +178,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -185,9 +190,11 @@ + POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); + POLYBENCH_2D_ARRAY_DECL(R,DATA_TYPE,NJ,NJ,nj,nj); + POLYBENCH_2D_ARRAY_DECL(Q,DATA_TYPE,NI,NJ,ni,nj); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(A_StrictFP,DATA_TYPE,NI,NJ,ni,nj); + POLYBENCH_2D_ARRAY_DECL(R_StrictFP,DATA_TYPE,NJ,NJ,nj,nj); + POLYBENCH_2D_ARRAY_DECL(Q_StrictFP,DATA_TYPE,NI,NJ,ni,nj); ++#endif + + /* Initialize array(s). */ + init_array (ni, nj, +@@ -208,6 +215,14 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(ni, nj, ++ POLYBENCH_ARRAY(A), ++ POLYBENCH_ARRAY(R), ++ POLYBENCH_ARRAY(Q))); ++#else + init_array (ni, nj, + POLYBENCH_ARRAY(A_StrictFP), + POLYBENCH_ARRAY(R_StrictFP), +@@ -230,14 +245,17 @@ + POLYBENCH_ARRAY(A_StrictFP), + POLYBENCH_ARRAY(R_StrictFP), + POLYBENCH_ARRAY(Q_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(R); + POLYBENCH_FREE_ARRAY(Q); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(A_StrictFP); + POLYBENCH_FREE_ARRAY(R_StrictFP); + POLYBENCH_FREE_ARRAY(Q_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c +@@ -80,6 +80,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_lu_StrictFP(int n, + DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) +@@ -127,6 +131,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -135,7 +140,9 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); ++#endif + + /* Initialize array(s). */ + init_array (n, POLYBENCH_ARRAY(A)); +@@ -150,6 +157,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); ++#else + init_array (n, POLYBENCH_ARRAY(A_StrictFP)); + kernel_lu (n, POLYBENCH_ARRAY(A_StrictFP)); + if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP))) +@@ -158,10 +170,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(A_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c +--- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c ++++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c +@@ -109,6 +109,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_ludcmp_StrictFP(int n, + DATA_TYPE POLYBENCH_2D(A,N+1,N+1,n+1,n+1), +@@ -179,6 +183,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -189,7 +194,9 @@ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N+1, N+1, n+1, n+1); + POLYBENCH_1D_ARRAY_DECL(b, DATA_TYPE, N+1, n+1); + POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N+1, n+1); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(x_StrictFP, DATA_TYPE, N+1, n+1); ++#endif + POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N+1, n+1); + + +@@ -214,6 +221,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X))); ++#else + init_array (n, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(b), +@@ -230,12 +242,15 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(b); + POLYBENCH_FREE_ARRAY(x); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(x_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(y); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c b/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c +--- a/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c ++++ b/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c +@@ -71,6 +71,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_floyd_warshall_StrictFP(int n, DATA_TYPE POLYBENCH_2D(path,N,N,n,n)) + { +@@ -110,6 +114,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -118,7 +123,9 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, N, N, n, n); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(path_StrictFP, DATA_TYPE, N, N, n, n); ++#endif + + /* Initialize array(s). */ + init_array (n, POLYBENCH_ARRAY(path)); +@@ -133,6 +140,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(path))); ++#else + init_array (n, POLYBENCH_ARRAY(path_StrictFP)); + kernel_floyd_warshall_StrictFP(n, POLYBENCH_ARRAY(path_StrictFP)); + if (!check_FP(n, POLYBENCH_ARRAY(path), POLYBENCH_ARRAY(path_StrictFP))) +@@ -141,10 +153,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(path_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(path); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(path_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c b/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c +--- a/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c ++++ b/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c +@@ -100,6 +100,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_reg_detect_StrictFP(int niter, int maxgrid, int length, + DATA_TYPE POLYBENCH_2D(sum_tang,MAXGRID,MAXGRID,maxgrid,maxgrid), +@@ -162,6 +166,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -174,7 +179,9 @@ + POLYBENCH_2D_ARRAY_DECL(sum_tang, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); + POLYBENCH_2D_ARRAY_DECL(mean, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); + POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(path_StrictFP, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); ++#endif + POLYBENCH_3D_ARRAY_DECL(diff, DATA_TYPE, MAXGRID, MAXGRID, LENGTH, maxgrid, maxgrid, length); + POLYBENCH_3D_ARRAY_DECL(sum_diff, DATA_TYPE, MAXGRID, MAXGRID, LENGTH, maxgrid, maxgrid, length); + +@@ -199,6 +206,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(maxgrid, POLYBENCH_ARRAY(path))); ++#else + init_array (maxgrid, + POLYBENCH_ARRAY(sum_tang), + POLYBENCH_ARRAY(mean), +@@ -215,12 +227,15 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(maxgrid, POLYBENCH_ARRAY(path_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(sum_tang); + POLYBENCH_FREE_ARRAY(mean); + POLYBENCH_FREE_ARRAY(path); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(path_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(diff); + POLYBENCH_FREE_ARRAY(sum_diff); + +diff --git a/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt +--- a/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt ++++ b/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt +@@ -3,6 +3,10 @@ + if(SMALL_PROBLEM_SIZE) + list(APPEND CFLAGS -DSMALL_DATASET) + endif() ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++ + set(HASH_PROGRAM_OUTPUT 1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) + llvm_singlesource() +diff --git a/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c b/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c +--- a/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c ++++ b/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c +@@ -102,6 +102,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_adi_StrictFP(int tsteps, + int n, +@@ -167,6 +171,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -176,7 +181,9 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(X, DATA_TYPE, N, N, n, n); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(X_StrictFP, DATA_TYPE, N, N, n, n); ++#endif + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); + POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); + +@@ -195,6 +202,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X))); ++#else + init_array (n, POLYBENCH_ARRAY(X_StrictFP), POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(B)); + kernel_adi (tsteps, n, POLYBENCH_ARRAY(X_StrictFP), +@@ -205,10 +217,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(X); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(X_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(A); + POLYBENCH_FREE_ARRAY(B); + +diff --git a/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c b/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c +--- a/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c ++++ b/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c +@@ -104,6 +104,10 @@ + #pragma endscop + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_fdtd_2d_StrictFP(int tmax, + int nx, +@@ -157,6 +161,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -169,9 +174,11 @@ + POLYBENCH_2D_ARRAY_DECL(ex,DATA_TYPE,NX,NY,nx,ny); + POLYBENCH_2D_ARRAY_DECL(ey,DATA_TYPE,NX,NY,nx,ny); + POLYBENCH_2D_ARRAY_DECL(hz,DATA_TYPE,NX,NY,nx,ny); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(ex_StrictFP,DATA_TYPE,NX,NY,nx,ny); + POLYBENCH_2D_ARRAY_DECL(ey_StrictFP,DATA_TYPE,NX,NY,nx,ny); + POLYBENCH_2D_ARRAY_DECL(hz_StrictFP,DATA_TYPE,NX,NY,nx,ny); ++#endif + POLYBENCH_1D_ARRAY_DECL(_fict_,DATA_TYPE,TMAX,tmax); + + /* Initialize array(s). */ +@@ -196,6 +203,13 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(ex), ++ POLYBENCH_ARRAY(ey), ++ POLYBENCH_ARRAY(hz))); ++#else + init_array (tmax, nx, ny, + POLYBENCH_ARRAY(ex_StrictFP), + POLYBENCH_ARRAY(ey_StrictFP), +@@ -212,14 +226,17 @@ + polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(ex_StrictFP), + POLYBENCH_ARRAY(ey_StrictFP), + POLYBENCH_ARRAY(hz_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(ex); + POLYBENCH_FREE_ARRAY(ey); + POLYBENCH_FREE_ARRAY(hz); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(ex_StrictFP); + POLYBENCH_FREE_ARRAY(ey_StrictFP); + POLYBENCH_FREE_ARRAY(hz_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(_fict_); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c b/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c +--- a/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c ++++ b/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c +@@ -166,6 +166,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_fdtd_apml_StrictFP(int cz, + int cxm, +@@ -253,6 +257,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -272,10 +277,12 @@ + POLYBENCH_3D_ARRAY_DECL(Ex,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); + POLYBENCH_3D_ARRAY_DECL(Ey,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); + POLYBENCH_3D_ARRAY_DECL(Hz,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); ++#if !FMA_DISABLED + POLYBENCH_3D_ARRAY_DECL(Bza_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); + POLYBENCH_3D_ARRAY_DECL(Ex_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); + POLYBENCH_3D_ARRAY_DECL(Ey_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); + POLYBENCH_3D_ARRAY_DECL(Hz_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); ++#endif + POLYBENCH_1D_ARRAY_DECL(czm,DATA_TYPE,CZ+1,cz+1); + POLYBENCH_1D_ARRAY_DECL(czp,DATA_TYPE,CZ+1,cz+1); + POLYBENCH_1D_ARRAY_DECL(cxmh,DATA_TYPE,CXM+1,cxm+1); +@@ -321,6 +328,15 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(cz, cxm, cym, ++ POLYBENCH_ARRAY(Bza), ++ POLYBENCH_ARRAY(Ex), ++ POLYBENCH_ARRAY(Ey), ++ POLYBENCH_ARRAY(Hz))); ++#else + init_array (cz, cxm, cym, &mui, &ch, + POLYBENCH_ARRAY(Ax), + POLYBENCH_ARRAY(Ry), +@@ -364,6 +380,7 @@ + POLYBENCH_ARRAY(Ex_StrictFP), + POLYBENCH_ARRAY(Ey_StrictFP), + POLYBENCH_ARRAY(Hz_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(Ax); +@@ -374,10 +391,12 @@ + POLYBENCH_FREE_ARRAY(Ex); + POLYBENCH_FREE_ARRAY(Ey); + POLYBENCH_FREE_ARRAY(Hz); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(Bza_StrictFP); + POLYBENCH_FREE_ARRAY(Ex_StrictFP); + POLYBENCH_FREE_ARRAY(Ey_StrictFP); + POLYBENCH_FREE_ARRAY(Hz_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(czm); + POLYBENCH_FREE_ARRAY(czp); + POLYBENCH_FREE_ARRAY(cxmh); +diff --git a/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c b/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c +--- a/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c ++++ b/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c +@@ -74,6 +74,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_jacobi_1d_imper_StrictFP(int tsteps, + int n, +@@ -114,6 +118,7 @@ + + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -123,7 +128,9 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_1D_ARRAY_DECL(A, DATA_TYPE, N, n); ++#if !FMA_DISABLED + POLYBENCH_1D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, n); ++#endif + POLYBENCH_1D_ARRAY_DECL(B, DATA_TYPE, N, n); + + +@@ -140,6 +147,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); ++#else + init_array (n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B)); + kernel_jacobi_1d_imper (tsteps, n, POLYBENCH_ARRAY(A_StrictFP), + POLYBENCH_ARRAY(B)); +@@ -149,6 +161,7 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); +diff --git a/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c b/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c +--- a/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c ++++ b/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c +@@ -79,6 +79,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_jacobi_2d_imper_StrictFP(int tsteps, + int n, +@@ -123,6 +127,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -132,7 +137,9 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); ++#endif + POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); + + +@@ -149,6 +156,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); ++#else + init_array (n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B)); + kernel_jacobi_2d_imper_StrictFP(tsteps, n, POLYBENCH_ARRAY(A_StrictFP), + POLYBENCH_ARRAY(B)); +@@ -158,10 +170,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(A_StrictFP); ++#endif + POLYBENCH_FREE_ARRAY(B); + + return 0; +diff --git a/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c b/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c +--- a/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c ++++ b/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c +@@ -71,6 +71,10 @@ + + } + ++#if !FMA_DISABLED ++// NOTE: FMA_DISABLED is true for targets where FMA contraction causes ++// discrepancies which cause the accuracy checks to fail. ++// In this case, the test runs with the option -ffp-contract=off + static void + kernel_seidel_2d_StrictFP(int tsteps, + int n, +@@ -111,6 +115,7 @@ + /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ + return 1; + } ++#endif + + int main(int argc, char** argv) + { +@@ -120,7 +125,9 @@ + + /* Variable declaration/allocation. */ + POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); ++#if !FMA_DISABLED + POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); ++#endif + + + /* Initialize array(s). */ +@@ -136,6 +143,11 @@ + polybench_stop_instruments; + polybench_print_instruments; + ++#if FMA_DISABLED ++ /* Prevent dead-code elimination. All live-out data must be printed ++ by the function call in argument. */ ++ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); ++#else + init_array (n, POLYBENCH_ARRAY(A_StrictFP)); + kernel_seidel_2d (tsteps, n, POLYBENCH_ARRAY(A_StrictFP)); + +@@ -145,10 +157,13 @@ + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); ++#endif + + /* Be clean. */ + POLYBENCH_FREE_ARRAY(A); ++#if !FMA_DISABLED + POLYBENCH_FREE_ARRAY(A_StrictFP); ++#endif + + return 0; + } +diff --git a/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt b/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt +--- a/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt ++++ b/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt +@@ -2,4 +2,7 @@ + list(APPEND LDFLAGS -lm) + list(APPEND TARGET_FLAGS -msse2) + list(APPEND LCCFLAGS -msse2) ++# Floating point contraction must be suppressed due to accuracy issues ++list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) ++list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource(PREFIX "Vector-") + diff --git a/llvm_test_script/generate_config.py b/llvm_test_script/generate_config.py index fb21fc7..5775853 100755 --- a/llvm_test_script/generate_config.py +++ b/llvm_test_script/generate_config.py @@ -7,6 +7,7 @@ target_list = ( 'aarch64-linux-hos', 'arm-linux-ohos', 'aarch64-linux-ohos', + 'aarch64-linux-gnu', 'arm-liteos', 'arm-linux-hos', 'x86_64-linux-hos', diff --git a/llvm_test_script/run_aarch64_O2-test.sh b/llvm_test_script/run_aarch64_O2-test.sh new file mode 100644 index 0000000..663db37 --- /dev/null +++ b/llvm_test_script/run_aarch64_O2-test.sh @@ -0,0 +1,113 @@ +#!/bin/bash + +WORK_DIR=${PWD} +PATH_TO_LLVM_TEST_SUITE=${WORK_DIR}/../llvm-test-suite +OHOS_SYSROOT=${WORK_DIR}/../llvm_tool/sysroot +OHOS_BUILD=${WORK_DIR}/../llvm_tool/clang + +run_order=1 +toolchain_type=ohos +options= + +while [[ $# -gt 0 ]] +do + case $1 in + -o|--run-order) + run_order="$2" + shift 2 + ;; + -e|--exclude) + exclude="$2" + shift 2 + ;; + -b|--build-dir) + options+=" --build-dir $2" + shift 2 + ;; + --only-execute) + options+=" --only-execute" + shift + ;; + --exec-multisample) + options+=" --exec-multisample $2" + shift 2 + ;; + --emui) + toolchain_type=emui + shift + ;; + --ohos) + toolchain_type=ohos + shift + ;; + *) + echo "Unknown option $1" + exit 1 + ;; + esac +done + +if [[ ${toolchain_type} == emui ]]; then + CFG_FILE=${LLVM_CI}/resources/config/aarch64-linux-android29.cfg + SYSROOT=${EMUI_SYSROOT} + BUILD=${EMUI_BUILD} + ADDITIONAL_OPTIONS=" \ + --cmake-define AOSP_COMPILER_LIBCXX_BUILD_PATH=${BUILD}/lib64/clang/9.0.3/lib/linux/aarch64 \ + --cmake-define AOSP_COMPILER_BIN_PATH=${BUILD}/bin \ + --cmake-define AOSP_LLVM_TOOLCHAIN_BASE=${BUILD} \ + --cmake-define AOSP_COMPILER_OUT_PATH=${BUILD} \ + --device-push-shared-libs ${BUILD}/lib64/clang/9.0.3/lib/linux/aarch64/libc++.so \ + --cmake-define CMAKE_SYSROOT=${SYSROOT} \ + " +else + TARGET_TRIPLE=aarch64-linux-gnu + CFG_FILE=${WORK_DIR}/aarch64-linux-hos.cfg + SYSROOT=${OHOS_SYSROOT} + BUILD=${OHOS_BUILD} + ADDITIONAL_OPTIONS=" \ + --cmake-define TOOLCHAIN_OUT=${BUILD} \ + --cmake-define SYSROOT_OUT=${SYSROOT} \ + --cmake-define TEST_SUITE_BUILD_TARGET="${TARGET_TRIPLE}" \ + " +fi + +python3 ${WORK_DIR}/generate_config.py --target ${TARGET_TRIPLE} \ + --clang ${BUILD} \ + --sysroot ${SYSROOT} \ + --out ${WORK_DIR} \ + --default ${CFG_FILE} + +TOOLCHAIN_BIN_PATH=${BUILD}/bin + +DISABLED_TESTS="LMbench" +if [[ "${exclude}" ]]; then + DISABLED_TESTS+=";$(eval "cat ${exclude}" | grep -v '^#' | paste -sd ';' -)" +fi +options+=" --cmake-define DISABLED_TESTS=${DISABLED_TESTS};" + + +set -x +lnt runtest test-suite --no-auto-name \ + --sandbox ${WORK_DIR}/LNT_log_O2/ \ + --test-suite ${PATH_TO_LLVM_TEST_SUITE} \ + --cc=${BUILD}/bin/clang \ + --cxx=${BUILD}/bin/clang++ \ + --cppflags "-O3 -DNDEBUG -DBIONIC_IOCTL_NO_SIGNEDNESS_OVERLOAD -DSPEC_CPU_NO_USE_STDIO_PTR -DSPEC_CPU_NO_USE_STDIO_BASE --verbose" \ + --cppflags=-O2 \ + --cmake-define TEST_SUITE_COLLECT_COMPILE_TIME=OFF \ + --cmake-define TEST_SUITE_COLLECT_CODE_SIZE=OFF \ + --cmake-define=CMAKE_EXE_LINKER_FLAGS="-fuse-ld=/home/tools/llvm/bin/ld.lld" \ + --cmake-define=BUILD_SHARED_LIBS=OFF \ + --use-lit=$(which lit) \ + --use-cmake=/usr/bin/cmake \ + --exclude-stat-from-submission compile \ + --exclude-stat-from-submission hash \ + ${ADDITIONAL_OPTIONS} \ + --run-order $run_order \ + --build-threads 8 \ + --threads 1 \ + --cmake-define 'DISABLED_TESTS=LMbench;/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR;/MultiSource/Applications/FFmpeg;initp1;;/MicroBenchmarks/XRay;/MultiSource/Benchmarks/BenchCompress/PGO;/MultiSource/Benchmarks/BenchCompress/Instrument;/MultiSource/Benchmarks/BenchCompress/Normal;/SingleSource/Huawei/libc_basic/libomp_basic;/MultiSource/Benchmarks/LZ4/lz4k;;/MultiSource/Benchmarks/Prolangs-C/unix-smail;/MultiSource/Benchmarks/BenchCompress/Instrument;/MultiSource/Benchmarks/BenchCompress/Normal;/MultiSource/Benchmarks/BenchCompress/PGO;/MultiSource/Benchmarks/LZ4/lz4k;initp1;;GCC-C-execute-990413-2;GCC-C-execute-complex-5;/MultiSource/Benchmarks/MiBench/office-ispell' \ + --perf-events=cpu-cycles,instructions \ + ${options} \ + + diff --git a/llvm_test_script/run_aarch64_docker.sh b/llvm_test_script/run_aarch64_docker.sh new file mode 100644 index 0000000..a280a86 --- /dev/null +++ b/llvm_test_script/run_aarch64_docker.sh @@ -0,0 +1,198 @@ +git config --global user.name "maxsu" +git config --global user.email "yiibai.com@gmail.com" + +check_mode=0 +while getopts "t:sh" opt +do + case $opt in + t) + check_type=$* + ;; + s) + check_mode=1 + ;; + h) + echo "Usage: ./run_docker.sh [-t={asan,fuzz,ndk,checksec,pugin}] [OPTION]" + echo + echo "Options are:" + echo " -t target: asan/fuzz/ndk/checksec/pugin" + echo " -h" + exit 0 + ;; + ?) + echo "unknown options" + exit 1 + ;; + esac +done + +# 门禁上路径是/home/pool_002/harmony_master +WORK_DIR=${PWD} +startruntime=`date +%s` +# llvmts +# llvmts + patch : ${WORK_DIR}/llvm-test-suite +git clone https://gitee.com/liwentao_uiw/llvm-test-suite.git ${WORK_DIR}/llvm-test-suite/ +(cd ${WORK_DIR}/llvm-test-suite/; git reset --hard 638914) + + +if [ -d ${WORK_DIR}/llvmopen-source-transfer-gitee ];then + cd ${WORK_DIR}/llvmopen-source-transfer-gitee + git pull +else + git clone https://gitee.com/liwentao_uiw/llvmopen-source-transfer-gitee.git -b ohos_toolchain ${WORK_DIR}/llvmopen-source-transfer-gitee/ + cd ${WORK_DIR}/llvmopen-source-transfer-gitee/ + git fetch https://gitee.com/liwentao_uiw/llvmopen-source-transfer-gitee.git pull/29/head:pr_29 + git merge pr_29 --no-edit +fi +(cd ${WORK_DIR}/llvmopen-source-transfer-gitee ; cp ./LLVMTS/638914_to_ed298b.patch ${WORK_DIR}/llvm-test-suite/; cp ./LLVMTS/D102861.diff ${WORK_DIR}/llvm-test-suite/) +(cd ${WORK_DIR}/llvm-test-suite; cat 638914_to_ed298b.patch | patch -d ./ -p1 -E; git apply D102861.diff) +# sh 路径是 : ${WORK_DIR}/llvmts_scripts +if [ -d ${WORK_DIR}/llvmts_scripts ];then + rm -rf ${WORK_DIR}/llvmts_scripts +fi +(mkdir -p ${WORK_DIR}/llvmts_scripts;) +(cd ${WORK_DIR}/llvmopen-source-transfer-gitee/llvm_test_script ; cp generate_config.py run_aarch64_test.sh run_aarch64_O2-test.sh X86_whitelist.txt X86_O2_whitelist.txt ${WORK_DIR}/llvmts_scripts/ ) + +# pull openharmony code +if echo ${check_type} | grep asan; then + echo "pull openharmony code" + cd ${WORK_DIR}/llvmopen-source-transfer-gitee/llvm_test_script/asan + cp run_pull_oh.sh ${WORK_DIR}/ + cd ${WORK_DIR} + bash run_pull_oh.sh & +fi + +# prepare llvm source +if [ -d ${WORK_DIR}/llvm ]; then + rm -rf ${WORK_DIR}/llvm +fi +mkdir -p ${WORK_DIR}/llvm +cd ${WORK_DIR}/llvm +# download LLVM +echo "download LLVM" +repo init -u https://gitee.com/OpenHarmony/manifest.git -b master -m llvm-toolchain.xml +repo sync -c +repo forall -c 'git lfs pull' + +# update prebuilts +# bash ./toolchain/llvm-project/llvm-build/env_prepare.sh + +cd ${WORK_DIR}/llvm +buildtime_s=`date +%s` +echo "build llvm start" +# build +python3 ./toolchain/llvm-project/llvm-build/build.py --no-build windows + +buildtime_e=`date +%s` +sumbuildtime=$[ $buildtime_e - $buildtime_s ] +echo "the build sumtime ---->: " " $sumbuildtime" +# sysroot的路径在 llvm/packages/ohos-sysroot-dev.tar.bz2 , 解压后在 /home/openharmony/llvm_tool/sysroot +if [ -d ${WORK_DIR}/llvm_tool/ ]; then + rm -rf ${WORK_DIR}/llvm_tool +fi +mkdir ${WORK_DIR}/llvm_tool/ +tar -jxvf ${WORK_DIR}/llvm/packages/ohos-sysroot-dev.tar.bz2 -C ${WORK_DIR}/llvm_tool/ +tar -jxvf ${WORK_DIR}/llvm/packages/clang-dev-linux-aarch64.tar.bz2 -C ${WORK_DIR}/llvm_tool/ +mv ${WORK_DIR}/llvm_tool/clang-dev ${WORK_DIR}/llvm_tool/clang + +endruntime=`date +%s` +timebeforetest=$[ $endruntime - $startruntime ] +echo "the time before test is : ----->" "$timebeforetest" + +# start to test +cd ${WORK_DIR}/llvmopen-source-transfer-gitee/llvm_test_script + +# install missing dependency +# pip3 install pyyaml==5.1.2 -i https://pypi.tuna.tsinghua.edu.cn/simple some-package + +TIME=$(date +%Y%m%d%H%M%S) +time_dir=$(date +%Y-%m-%d) +llvmts_logdir="${WORK_DIR}/llvmts-log/${time_dir}" + +# make log +mkdir -p ${llvmts_logdir} + +# run lldb unit shell api tests +export LD_LIBRARY_PATH="${WORK_DIR}/llvm/out/llvm_make/lib:${WORK_DIR}/llvm/out/llvm_make/lib/aarch64-unknown-linux-gnu" +dest_path="${WORK_DIR}/llvm/out/llvm_make/tools/lldb/unittests/ScriptInterpreter" +if [ ! -d ${dest_path}/python3/ ]; then + ln -s "${WORK_DIR}/llvm/out/llvm_make/python3/" ${dest_path} +fi + +startTime=`date +%Y%m%d-%H:%M:%S` +startTime_s=`date +%s` +echo "test exec start" + +pushd ${WORK_DIR}/llvm/out/llvm_make +../../prebuilts/cmake/linux-aarch64/bin/ninja -v check-lldb-unit +unit=$? +./bin/llvm-lit -sv tools/lldb/test/Shell/ --max-time 300 +shell=$? +./bin/llvm-lit -sv tools/lldb/test/API/ --max-time 300 +api=$? +popd + + +#llvmts +pushd ${WORK_DIR}/llvmts_scripts +bash run_aarch64_test.sh 2>&1 | tee ${llvmts_logdir}/aarch64-linux-hos_${TIME}.txt & +bash run_aarch64_O2-test.sh 2>&1 | tee ${llvmts_logdir}/aarch64_linux-gnu-O2_${TIME}.txt & +popd + +wait + +echo "test exec done" +endTime=`date +%Y%m%d-%H:%M:%S` +endTime_s=`date +%s` +sumTime=$[ $endTime_s - $startTime_s ] + +echo "$startTime ---> $endTime" "Total:$sumTime seconds" + + +if [[ (-n "$unit" && $unit -gt 0) || $shell -eq 1 || $api -eq 1 ]]; then + exit 1 +fi + +X86=0 +X86_O2=0 +EXPECTATION_FAILED=0 +# 如果文件存在进行判断 +if [ -e ${llvmts_logdir}/aarch64-linux-hos_${TIME}.txt ]; then + X86="$(grep -E "[A-Z]+[a-z]+\s+:" ${llvmts_logdir}/aarch64-linux-hos_${TIME}.txt | grep "Passed" | tr -d [A-Z][a-z]' ': )" + (grep "Failed Tests" -A 300 ${llvmts_logdir}/aarch64-linux-hos_${TIME}.txt | grep "test-suite ::" 2>&1) | tee ${llvmts_logdir}/fail_aarch64.txt + (grep "Executable is missing Tests" -A 300 ${llvmts_logdir}/aarch64-linux-hos_${TIME}.txt | grep "test-suite ::" 2>&1) | tee -a ${llvmts_logdir}/fail_aarch64.txt + sed 's/.\{16\}//' ${llvmts_logdir}/fail_aarch64.txt 2>&1 | tee ${llvmts_logdir}/aarch64_failed_test.txt + for line in $(cat ${llvmts_logdir}/aarch64_failed_test.txt) + do + if [ `grep -c "$line" ${WORK_DIR}/llvmts_scripts/X86_whitelist.txt` -eq '0' ]; then + EXPECTATION_FAILED=1 + fi + done +fi + +if [ -e ${llvmts_logdir}/aarch64_linux-gnu-O2_${TIME}.txt ]; then + X86_O2="$(grep -E "[A-Z]+[a-z]+\s+:" ${llvmts_logdir}/aarch64_linux-gnu-O2_${TIME}.txt | grep "Passed" | tr -d [A-Z][a-z]' ': )" + (grep "Failed Tests" -A 300 ${llvmts_logdir}/aarch64_linux-gnu-O2_${TIME}.txt | grep "test-suite ::" 2>&1) | tee ${llvmts_logdir}/fail_aarch64_O2.txt + (grep "Executable is missing Tests" -A 300 ${llvmts_logdir}/aarch64_linux-gnu-O2_${TIME}.txt | grep "test-suite ::" 2>&1) | tee -a ${llvmts_logdir}/fail_aarch64_O2.txt + sed 's/.\{16\}//' ${llvmts_logdir}/fail_aarch64_O2.txt 2>&1 | tee ${llvmts_logdir}/aarch64_O2_failed_test.txt + for line in $(cat ${llvmts_logdir}/aarch64_O2_failed_test.txt) + do + if [ `grep -c "$line" ${WORK_DIR}/llvmts_scripts/X86_O2_whitelist.txt` -eq '0' ]; then + EXPECTATION_FAILED=1 + fi + done +fi + +#未执行成功，返回值为空时赋值 +if [ ! -n "$X86" ]; then + X86=0 +fi +if [ ! -n "$X86_O2" ]; then + X86_O2=0 +fi + +# 返回门禁 ：1以上都为失败 +#如果失败的用例不在whitelist里，表示测试失败了，且需要通过用例至少大于890，即未执行成功也判失败 +if [ $EXPECTATION_FAILED -eq 1 -o $X86 -lt 890 -o $X86_O2 -lt 890 ]; then + exit 1 +fi \ No newline at end of file diff --git a/llvm_test_script/run_aarch64_test.sh b/llvm_test_script/run_aarch64_test.sh new file mode 100644 index 0000000..8b18315 --- /dev/null +++ b/llvm_test_script/run_aarch64_test.sh @@ -0,0 +1,110 @@ +#!/bin/bash + +WORK_DIR=${PWD} +PATH_TO_LLVM_TEST_SUITE=${WORK_DIR}/../llvm-test-suite +OHOS_SYSROOT=${WORK_DIR}/../llvm_tool/sysroot +OHOS_BUILD=${WORK_DIR}/../llvm_tool/clang + +run_order=1 +toolchain_type=ohos +options= + +while [[ $# -gt 0 ]] +do + case $1 in + -o|--run-order) + run_order="$2" + shift 2 + ;; + -e|--exclude) + exclude="$2" + shift 2 + ;; + -b|--build-dir) + options+=" --build-dir $2" + shift 2 + ;; + --only-execute) + options+=" --only-execute" + shift + ;; + --exec-multisample) + options+=" --exec-multisample $2" + shift 2 + ;; + --emui) + toolchain_type=emui + shift + ;; + --ohos) + toolchain_type=ohos + shift + ;; + *) + echo "Unknown option $1" + exit 1 + ;; + esac +done + +if [[ ${toolchain_type} == emui ]]; then + CFG_FILE=${LLVM_CI}/resources/config/aarch64-linux-android29.cfg + SYSROOT=${EMUI_SYSROOT} + BUILD=${EMUI_BUILD} + ADDITIONAL_OPTIONS=" \ + --cmake-define AOSP_COMPILER_LIBCXX_BUILD_PATH=${BUILD}/lib64/clang/9.0.3/lib/linux/aarch64 \ + --cmake-define AOSP_COMPILER_BIN_PATH=${BUILD}/bin \ + --cmake-define AOSP_LLVM_TOOLCHAIN_BASE=${BUILD} \ + --cmake-define AOSP_COMPILER_OUT_PATH=${BUILD} \ + --device-push-shared-libs ${BUILD}/lib64/clang/9.0.3/lib/linux/aarch64/libc++.so \ + --cmake-define CMAKE_SYSROOT=${SYSROOT} \ + " +else + TARGET_TRIPLE=aarch64-linux-hos + CFG_FILE=${WORK_DIR}/aarch64-linux-hos.cfg + SYSROOT=${OHOS_SYSROOT} + BUILD=${OHOS_BUILD} + ADDITIONAL_OPTIONS=" \ + --cmake-define TOOLCHAIN_OUT=${BUILD} \ + --cmake-define SYSROOT_OUT=${SYSROOT} \ + --cmake-define TEST_SUITE_BUILD_TARGET="${TARGET_TRIPLE}" \ + " +fi + +python3 ${WORK_DIR}/generate_config.py --target ${TARGET_TRIPLE} \ + --clang ${BUILD} \ + --sysroot ${SYSROOT} \ + --out ${WORK_DIR} \ + --default ${CFG_FILE} + +TOOLCHAIN_BIN_PATH=${BUILD}/bin + +DISABLED_TESTS="LMbench" +if [[ "${exclude}" ]]; then + DISABLED_TESTS+=";$(eval "cat ${exclude}" | grep -v '^#' | paste -sd ';' -)" +fi +options+=" --cmake-define DISABLED_TESTS=${DISABLED_TESTS};" + + +set -x +lnt runtest test-suite --no-auto-name \ + --sandbox ${WORK_DIR}/LNT_log/ \ + --test-suite ${PATH_TO_LLVM_TEST_SUITE} \ + --cc=${BUILD}/bin/clang \ + --cxx=${BUILD}/bin/clang++ \ + --cppflags "-O3 -DNDEBUG -DBIONIC_IOCTL_NO_SIGNEDNESS_OVERLOAD -DSPEC_CPU_NO_USE_STDIO_PTR -DSPEC_CPU_NO_USE_STDIO_BASE --verbose" \ + --cmake-define TEST_SUITE_COLLECT_COMPILE_TIME=OFF \ + --cmake-define TEST_SUITE_COLLECT_CODE_SIZE=OFF \ + --cmake-define=CMAKE_EXE_LINKER_FLAGS="-fuse-ld=${TOOLCHAIN_BIN_PATH}/ld.lld -static" \ + --cmake-define=BUILD_SHARED_LIBS=OFF \ + --use-lit=$(which lit) \ + --use-cmake=/usr/bin/cmake \ + --exclude-stat-from-submission compile \ + --exclude-stat-from-submission hash \ + ${ADDITIONAL_OPTIONS} \ + --run-order $run_order \ + --build-threads 8 \ + --threads 1 \ + --cmake-define 'DISABLED_TESTS=LMbench;/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR;/MultiSource/Applications/FFmpeg;initp1;;/MicroBenchmarks/XRay;/MultiSource/Benchmarks/BenchCompress/PGO;/MultiSource/Benchmarks/BenchCompress/Instrument;/MultiSource/Benchmarks/BenchCompress/Normal;/SingleSource/Huawei/libc_basic/libomp_basic;/MultiSource/Benchmarks/LZ4/lz4k;;/MultiSource/Benchmarks/Prolangs-C/unix-smail;/MultiSource/Benchmarks/BenchCompress/Instrument;/MultiSource/Benchmarks/BenchCompress/Normal;/MultiSource/Benchmarks/BenchCompress/PGO;/MultiSource/Benchmarks/LZ4/lz4k;initp1;;GCC-C-execute-990413-2;GCC-C-execute-complex-5;/MultiSource/Benchmarks/MiBench/office-ispell' \ + --perf-events=cpu-cycles,instructions + -- Gitee