From 5910b7e57343b4241a5005d4bc27a03ec7765367 Mon Sep 17 00:00:00 2001 From: Julia Lapenko Date: Sat, 13 May 2023 17:30:18 +0300 Subject: [PATCH 1/2] [test] Disable several failing tests. --- tests/analysis/expr_matcher/pass | 8 ++++---- tests/transform/inline/pass | 16 ++++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/analysis/expr_matcher/pass b/tests/analysis/expr_matcher/pass index b6c474e..5fac5b3 100644 --- a/tests/analysis/expr_matcher/pass +++ b/tests/analysis/expr_matcher/pass @@ -1,7 +1,7 @@ parallel match_1/tsar -match_2/tsar -match_3/tsar +#match_2/tsar # works for windows only +#match_3/tsar # works for windows only match_4/tsar match_5/tsar match_6/tsar @@ -11,7 +11,7 @@ match_9/tsar match_10/tsar match_11/tsar match_12/tsar -#match_13/tsar +#match_13/tsar match_14/tsar match_15/tsar match_16/tsar @@ -21,6 +21,6 @@ match_19/tsar match_20/tsar match_21/tsar match_22/tsar -match_23/tsar +#match_23/tsar # works for windows only match_24/tsar end_parallel diff --git a/tests/transform/inline/pass b/tests/transform/inline/pass index dffed61..9035fc0 100644 --- a/tests/transform/inline/pass +++ b/tests/transform/inline/pass @@ -68,9 +68,9 @@ inline_class_1/tsar inline_class_2/tsar inline_enum_1/tsar inline_enum_2/tsar -inline_enum_3/tsar -inline_enum_3-CHECK-1/tsar -inline_forward_1/tsar +#inline_enum_3/tsar # unable to handle compilation +#inline_enum_3-CHECK-1/tsar # unable to handle compilation +#inline_forward_1/tsar # unable to handle compilation inline_forward_2/tsar inline_forward_3/tsar inline_forward_4/tsar @@ -111,18 +111,18 @@ inline_macro_26/tsar inline_macro_27/tsar inline_macro_28/tsar inline_macro_29/tsar -inline_merge_1/tsar -inline_merge_1-CHECK-1/tsar +#inline_merge_1/tsar # unable to handle compilation +#inline_merge_1-CHECK-1/tsar # unable to handle compilation inline_param_1/tsar inline_param_2/tsar inline_param_3/tsar inline_param_4/tsar -inline_param_5/tsar -inline_param_5-CHECK-1/tsar +#inline_param_5/tsar # unable to handle compilation +#inline_param_5-CHECK-1/tsar # unable to handle compilation inline_recursive_1/tsar inline_recursive_2/tsar inline_switch_1/tsar inline_unreachable_1/tsar inline_unreachable_2/tsar inline_unreachable_3/tsar -end_parallel \ No newline at end of file +end_parallel From 2b9815bc58723678abba7786ffebadc85593ee07 Mon Sep 17 00:00:00 2001 From: Julia Lapenko Date: Sat, 13 May 2023 20:09:35 +0300 Subject: [PATCH 2/2] [tsar, Dep] Add new tests for private arrays. --- tests/analysis/da_di/pass | 7 ++ .../da_di/private_array_var_bound_1/main.c | 15 +++ .../private_array_var_bound_1/sample/main.c | 15 +++ .../sample/output.txt | 70 ++++++++++++++ .../da_di/private_array_var_bound_1/tsar.conf | 8 ++ .../da_di/private_array_var_bound_2/main.c | 15 +++ .../private_array_var_bound_2/sample/main.c | 15 +++ .../sample/output.txt | 68 ++++++++++++++ .../da_di/private_array_var_bound_2/tsar.conf | 8 ++ .../da_di/private_array_var_bound_3/main.c | 10 ++ .../private_array_var_bound_3/sample/main.c | 10 ++ .../sample/output.txt | 70 ++++++++++++++ .../da_di/private_array_var_bound_3/tsar.conf | 8 ++ .../da_di/private_array_var_bound_4/main.c | 10 ++ .../private_array_var_bound_4/sample/main.c | 10 ++ .../sample/output.txt | 72 +++++++++++++++ .../da_di/private_array_var_bound_4/tsar.conf | 8 ++ .../da_di/private_array_var_bound_5/main.c | 16 ++++ .../private_array_var_bound_5/sample/main.c | 16 ++++ .../sample/output.txt | 70 ++++++++++++++ .../da_di/private_array_var_bound_5/tsar.conf | 8 ++ .../da_di/private_array_var_bound_6/main.c | 16 ++++ .../private_array_var_bound_6/sample/main.c | 16 ++++ .../sample/output.txt | 91 +++++++++++++++++++ .../da_di/private_array_var_bound_6/tsar.conf | 8 ++ .../da_di/private_array_var_bound_7/main.c | 13 +++ .../private_array_var_bound_7/sample/main.c | 13 +++ .../sample/output.txt | 68 ++++++++++++++ .../da_di/private_array_var_bound_7/tsar.conf | 8 ++ 29 files changed, 762 insertions(+) create mode 100644 tests/analysis/da_di/private_array_var_bound_1/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_1/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_1/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_1/tsar.conf create mode 100644 tests/analysis/da_di/private_array_var_bound_2/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_2/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_2/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_2/tsar.conf create mode 100644 tests/analysis/da_di/private_array_var_bound_3/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_3/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_3/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_3/tsar.conf create mode 100644 tests/analysis/da_di/private_array_var_bound_4/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_4/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_4/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_4/tsar.conf create mode 100644 tests/analysis/da_di/private_array_var_bound_5/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_5/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_5/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_5/tsar.conf create mode 100644 tests/analysis/da_di/private_array_var_bound_6/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_6/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_6/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_6/tsar.conf create mode 100644 tests/analysis/da_di/private_array_var_bound_7/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_7/sample/main.c create mode 100644 tests/analysis/da_di/private_array_var_bound_7/sample/output.txt create mode 100644 tests/analysis/da_di/private_array_var_bound_7/tsar.conf diff --git a/tests/analysis/da_di/pass b/tests/analysis/da_di/pass index 6ca5e2e..315788b 100644 --- a/tests/analysis/da_di/pass +++ b/tests/analysis/da_di/pass @@ -82,6 +82,13 @@ private_array_6/tsar private_array_7/tsar private_array_8/tsar private_array_9/tsar +private_array_var_bound_1/tsar +private_array_var_bound_2/tsar +private_array_var_bound_3/tsar +private_array_var_bound_4/tsar +private_array_var_bound_5/tsar +private_array_var_bound_6/tsar +private_array_var_bound_7/tsar reduction_1/tsar reduction_2/tsar reduction_3/tsar diff --git a/tests/analysis/da_di/private_array_var_bound_1/main.c b/tests/analysis/da_di/private_array_var_bound_1/main.c new file mode 100644 index 0000000..9e7265d --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_1/main.c @@ -0,0 +1,15 @@ +int A[10][2]; + +int f(int N) { + int S = 0; + __builtin_assume(N > 0); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) { + A[I][0] = I; + A[I][1] = I + 2; + } + for (int J = 0; J < N + 5; ++J) + S += A[J][0] * A[J][1]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_1/sample/main.c b/tests/analysis/da_di/private_array_var_bound_1/sample/main.c new file mode 100644 index 0000000..9e7265d --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_1/sample/main.c @@ -0,0 +1,15 @@ +int A[10][2]; + +int f(int N) { + int S = 0; + __builtin_assume(N > 0); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) { + A[I][0] = I; + A[I][1] = I + 2; + } + for (int J = 0; J < N + 5; ++J) + S += A[J][0] * A[J][1]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_1/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_1/sample/output.txt new file mode 100644 index 0000000..472fea6 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_1/sample/output.txt @@ -0,0 +1,70 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:6:5 + private: + | + output: + + anti: + + flow: + + induction: + :[Int,0,10,1] + reduction: + :add + read only: + + lock: + + header access: + + explicit access: + | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:11:9 + induction: + :[Int,0,,1] + reduction: + :add + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:7:9 + shared: + + first private: + + dynamic private: + + induction: + :[Int,0,,1] + read only: + + lock: + | + header access: + | + explicit access: + | + explicit access (separate): + + lock (separate): + + direct access (separate): + diff --git a/tests/analysis/da_di/private_array_var_bound_1/tsar.conf b/tests/analysis/da_di/private_array_var_bound_1/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_1/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1" diff --git a/tests/analysis/da_di/private_array_var_bound_2/main.c b/tests/analysis/da_di/private_array_var_bound_2/main.c new file mode 100644 index 0000000..53afaec --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_2/main.c @@ -0,0 +1,15 @@ +int A[10][2]; + +int f(int N) { + int S = 0; + __builtin_assume(N > 0); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) { + A[I][0] = I; + A[I][1] = I + 2; + } + for (int J = 0; J < N; ++J) + S += A[J][0] * A[J][1]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_2/sample/main.c b/tests/analysis/da_di/private_array_var_bound_2/sample/main.c new file mode 100644 index 0000000..53afaec --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_2/sample/main.c @@ -0,0 +1,15 @@ +int A[10][2]; + +int f(int N) { + int S = 0; + __builtin_assume(N > 0); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) { + A[I][0] = I; + A[I][1] = I + 2; + } + for (int J = 0; J < N; ++J) + S += A[J][0] * A[J][1]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_2/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_2/sample/output.txt new file mode 100644 index 0000000..360f02b --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_2/sample/output.txt @@ -0,0 +1,68 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:6:5 + first private: + + dynamic private: + + private: + | + induction: + :[Int,0,10,1] + reduction: + :add + read only: + + lock: + + header access: + + explicit access: + | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:11:9 + induction: + :[Int,0,,1] + reduction: + :add + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:7:9 + shared: + + first private: + + dynamic private: + + induction: + :[Int,0,,1] + read only: + + lock: + | + header access: + | + explicit access: + | + explicit access (separate): + + lock (separate): + + direct access (separate): + diff --git a/tests/analysis/da_di/private_array_var_bound_2/tsar.conf b/tests/analysis/da_di/private_array_var_bound_2/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_2/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1" diff --git a/tests/analysis/da_di/private_array_var_bound_3/main.c b/tests/analysis/da_di/private_array_var_bound_3/main.c new file mode 100644 index 0000000..9c79a92 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_3/main.c @@ -0,0 +1,10 @@ +void f(int * restrict A, int * restrict B, int N) { + __builtin_assume(N > 1); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) + A[I] = I * I; + B[0] = 0; + for (int I = 1; I < N; ++I) + B[I] = A[I] + A[I-1]; + } +} diff --git a/tests/analysis/da_di/private_array_var_bound_3/sample/main.c b/tests/analysis/da_di/private_array_var_bound_3/sample/main.c new file mode 100644 index 0000000..9c79a92 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_3/sample/main.c @@ -0,0 +1,10 @@ +void f(int * restrict A, int * restrict B, int N) { + __builtin_assume(N > 1); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) + A[I] = I * I; + B[0] = 0; + for (int I = 1; I < N; ++I) + B[I] = A[I] + A[I-1]; + } +} diff --git a/tests/analysis/da_di/private_array_var_bound_3/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_3/sample/output.txt new file mode 100644 index 0000000..a704fc3 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_3/sample/output.txt @@ -0,0 +1,70 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:3:5 + first private: + <*A:1, +?> | <*B:1, +?> + dynamic private: + <*A:1, +?> | <*B:1, +?> + private: + | + induction: + :[Int,0,10,1] + read only: + | | + lock: + + header access: + + explicit access: + | | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> <*B:1, +?> + loop at depth 2 main.c:7:9 + shared: + <*B:1, +?> + first private: + <*B:1, +?> + dynamic private: + <*B:1, +?> + induction: + :[Int,1,,1] + read only: + <*A:1, +?> | | | + lock: + | + header access: + | + explicit access: + | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> <*B:1, +?> + loop at depth 2 main.c:4:9 + shared: + <*A:1, +?> + first private: + <*A:1, +?> + dynamic private: + <*A:1, +?> + induction: + :[Int,0,,1] + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> diff --git a/tests/analysis/da_di/private_array_var_bound_3/tsar.conf b/tests/analysis/da_di/private_array_var_bound_3/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_3/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1" diff --git a/tests/analysis/da_di/private_array_var_bound_4/main.c b/tests/analysis/da_di/private_array_var_bound_4/main.c new file mode 100644 index 0000000..d7c445b --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_4/main.c @@ -0,0 +1,10 @@ +void f(int *A, int *B, int N) { + __builtin_assume(N > 1); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) + A[I] = I * I; + B[0] = 0; + for (int I = 1; I < N; ++I) + B[I] = A[I] + A[I-1]; + } +} diff --git a/tests/analysis/da_di/private_array_var_bound_4/sample/main.c b/tests/analysis/da_di/private_array_var_bound_4/sample/main.c new file mode 100644 index 0000000..d7c445b --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_4/sample/main.c @@ -0,0 +1,10 @@ +void f(int *A, int *B, int N) { + __builtin_assume(N > 1); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) + A[I] = I * I; + B[0] = 0; + for (int I = 1; I < N; ++I) + B[I] = A[I] + A[I-1]; + } +} diff --git a/tests/analysis/da_di/private_array_var_bound_4/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_4/sample/output.txt new file mode 100644 index 0000000..5823341 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_4/sample/output.txt @@ -0,0 +1,72 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:3:5 + private: + | + output: + <*A:1, +?> <*B:1, +?> + anti: + <*A:1, +?> <*B:1, +?> + flow: + <*A:1, +?> <*B:1, +?> + induction: + :[Int,0,10,1] + read only: + | | + lock: + + header access: + + explicit access: + | | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> <*B:1, +?> + loop at depth 2 main.c:7:9 + output: + <*A:1, +?> <*B:1, +?> + anti: + <*A:1, +?> <*B:1, +?> + flow: + <*A:1, +?> <*B:1, +?> + induction: + :[Int,1,,1] + read only: + | | + lock: + | + header access: + | + explicit access: + | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> <*B:1, +?> + loop at depth 2 main.c:4:9 + shared: + <*A:1, +?> + first private: + <*A:1, +?> + dynamic private: + <*A:1, +?> + induction: + :[Int,0,,1] + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> diff --git a/tests/analysis/da_di/private_array_var_bound_4/tsar.conf b/tests/analysis/da_di/private_array_var_bound_4/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_4/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1" diff --git a/tests/analysis/da_di/private_array_var_bound_5/main.c b/tests/analysis/da_di/private_array_var_bound_5/main.c new file mode 100644 index 0000000..73855f1 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_5/main.c @@ -0,0 +1,16 @@ +int f(int A[10][2], int N) { + int S = 0; + __builtin_assume(N > 0); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) { + A[I][0] = I; + A[I][1] = I + 2; + } + // TODO: Use set for this loop contains the memory location . + // It is related to the first function argument. + // It prevents A[10][2] from being defined as private. + for (int J = 0; J < N; ++J) + S += A[J][1] * A[J][1]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_5/sample/main.c b/tests/analysis/da_di/private_array_var_bound_5/sample/main.c new file mode 100644 index 0000000..73855f1 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_5/sample/main.c @@ -0,0 +1,16 @@ +int f(int A[10][2], int N) { + int S = 0; + __builtin_assume(N > 0); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) { + A[I][0] = I; + A[I][1] = I + 2; + } + // TODO: Use set for this loop contains the memory location . + // It is related to the first function argument. + // It prevents A[10][2] from being defined as private. + for (int J = 0; J < N; ++J) + S += A[J][1] * A[J][1]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_5/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_5/sample/output.txt new file mode 100644 index 0000000..65114d7 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_5/sample/output.txt @@ -0,0 +1,70 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:4:5 + private: + | + output: + <*A:1, +?> + anti: + <*A:1, +?> + flow: + <*A:1, +?> + induction: + :[Int,0,10,1] + reduction: + :add + read only: + | + lock: + + header access: + + explicit access: + | | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> + loop at depth 2 main.c:12:9 + induction: + :[Int,0,,1] + reduction: + :add + read only: + <*A:1, +?> | | + lock: + | + header access: + | + explicit access: + | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> + loop at depth 2 main.c:5:9 + shared: + <*A:1, +?> + first private: + <*A:1, +?> + dynamic private: + <*A:1, +?> + induction: + :[Int,0,,1] + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + <*A:1, +?> diff --git a/tests/analysis/da_di/private_array_var_bound_5/tsar.conf b/tests/analysis/da_di/private_array_var_bound_5/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_5/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1" diff --git a/tests/analysis/da_di/private_array_var_bound_6/main.c b/tests/analysis/da_di/private_array_var_bound_6/main.c new file mode 100644 index 0000000..8d7dd69 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_6/main.c @@ -0,0 +1,16 @@ +int A[100]; + +int f(int M, int N) { + int S = 0; + __builtin_assume(M > 0); + __builtin_assume(M < N); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < M; I++) + A[I] = I + I; + for (int I = M; I < N; I++) + A[I] = 42 * I; + for (int I = 0; I < N; I++) + S += A[I]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_6/sample/main.c b/tests/analysis/da_di/private_array_var_bound_6/sample/main.c new file mode 100644 index 0000000..8d7dd69 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_6/sample/main.c @@ -0,0 +1,16 @@ +int A[100]; + +int f(int M, int N) { + int S = 0; + __builtin_assume(M > 0); + __builtin_assume(M < N); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < M; I++) + A[I] = I + I; + for (int I = M; I < N; I++) + A[I] = 42 * I; + for (int I = 0; I < N; I++) + S += A[I]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_6/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_6/sample/output.txt new file mode 100644 index 0000000..09a5456 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_6/sample/output.txt @@ -0,0 +1,91 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:7:2 + first private: + + dynamic private: + + private: + | | + induction: + :[Int,0,10,1] + reduction: + :add + read only: + | + lock: + + header access: + + explicit access: + | | | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:12:3 + induction: + :[Int,0,,1] + reduction: + :add + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:10:6 + shared: + + first private: + + dynamic private: + + induction: + :[Int,,,1] + read only: + + lock: + | + header access: + | + explicit access: + | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:8:6 + shared: + + first private: + + dynamic private: + + induction: + :[Int,0,,1] + read only: + + lock: + | + header access: + | + explicit access: + | + explicit access (separate): + + lock (separate): + + direct access (separate): + diff --git a/tests/analysis/da_di/private_array_var_bound_6/tsar.conf b/tests/analysis/da_di/private_array_var_bound_6/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_6/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1" diff --git a/tests/analysis/da_di/private_array_var_bound_7/main.c b/tests/analysis/da_di/private_array_var_bound_7/main.c new file mode 100644 index 0000000..7816be4 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_7/main.c @@ -0,0 +1,13 @@ +int A[100]; + +int f(int N) { + int S = 0; + __builtin_assume(N > 4); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) + A[I] = I + I; + for (int I = 2; I < N-2; I++) + S += A[I]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_7/sample/main.c b/tests/analysis/da_di/private_array_var_bound_7/sample/main.c new file mode 100644 index 0000000..7816be4 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_7/sample/main.c @@ -0,0 +1,13 @@ +int A[100]; + +int f(int N) { + int S = 0; + __builtin_assume(N > 4); + for (int K = 0; K < 10; K++) { + for (int I = 0; I < N; I++) + A[I] = I + I; + for (int I = 2; I < N-2; I++) + S += A[I]; + } + return S; +} diff --git a/tests/analysis/da_di/private_array_var_bound_7/sample/output.txt b/tests/analysis/da_di/private_array_var_bound_7/sample/output.txt new file mode 100644 index 0000000..a4dfe61 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_7/sample/output.txt @@ -0,0 +1,68 @@ +Printing analysis 'Dependency Analysis (Metadata)' for function 'f': + loop at depth 1 main.c:6:2 + first private: + + dynamic private: + + private: + | + induction: + :[Int,0,10,1] + reduction: + :add + read only: + + lock: + + header access: + + explicit access: + | | | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:9:3 + induction: + :[Int,2,,1] + reduction: + :add + read only: + | + lock: + | + header access: + | + explicit access: + | | + explicit access (separate): + + lock (separate): + + direct access (separate): + + loop at depth 2 main.c:7:6 + shared: + + first private: + + dynamic private: + + induction: + :[Int,0,,1] + read only: + + lock: + | + header access: + | + explicit access: + | + explicit access (separate): + + lock (separate): + + direct access (separate): + diff --git a/tests/analysis/da_di/private_array_var_bound_7/tsar.conf b/tests/analysis/da_di/private_array_var_bound_7/tsar.conf new file mode 100644 index 0000000..2246556 --- /dev/null +++ b/tests/analysis/da_di/private_array_var_bound_7/tsar.conf @@ -0,0 +1,8 @@ +plugin = TsarPlugin +add_include_path = $include +sources = main.c +copy = $sources +sample = $copy output.txt +clean = $sample +options = -print-only=da-di -print-step=4 +run = "$tsar $sources $options >output.txt 2>&1"