maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/polly/test/ScopInfo/reduction_multiple_loops_ar...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

73 lines
2.2 KiB
LLVM
Raw Normal View History

tests: Drop -polly-detect-unprofitable and -polly-no-early-exit These flags are now always passed to all tests and need to be disabled if not needed. Disabling these flags, rather than passing them to almost all tests, significantly simplfies our RUN: lines. llvm-svn: 249422
2015-10-06 23:36:44 +08:00
; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
;
; CHECK: Stmt_for_body
Introduce reduction types This change is particularly useful in the code generation as we need to know which binary operator/identity element we need to combine/initialize the privatization locations. + Print the reduction type for each memory access + Adjusted the test cases to comply with the new output format and to test for the right reduction type llvm-svn: 212126
2014-07-02 04:52:51 +08:00
; CHECK: Reduction Type: NONE
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_sum_04
Introduce reduction types This change is particularly useful in the code generation as we need to know which binary operator/identity element we need to combine/initialize the privatization locations. + Print the reduction type for each memory access + Adjusted the test cases to comply with the new output format and to test for the right reduction type llvm-svn: 212126
2014-07-02 04:52:51 +08:00
; CHECK: Reduction Type: NONE
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_sum_12
; CHECK: Stmt_for_inc
Change the printing of reduction types We use the C operator representation when applicable. + Update all the test cases accordingly. llvm-svn: 214486
2014-08-01 16:13:25 +08:00
; CHECK: Reduction Type: +
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_sum_12
Introduce reduction types This change is particularly useful in the code generation as we need to know which binary operator/identity element we need to combine/initialize the privatization locations. + Print the reduction type for each memory access + Adjusted the test cases to comply with the new output format and to test for the right reduction type llvm-svn: 212126
2014-07-02 04:52:51 +08:00
; CHECK: Reduction Type: NONE
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_A
Change the printing of reduction types We use the C operator representation when applicable. + Update all the test cases accordingly. llvm-svn: 214486
2014-08-01 16:13:25 +08:00
; CHECK: Reduction Type: +
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_sum_12
; CHECK: Stmt_for_inc5
Introduce reduction types This change is particularly useful in the code generation as we need to know which binary operator/identity element we need to combine/initialize the privatization locations. + Print the reduction type for each memory access + Adjusted the test cases to comply with the new output format and to test for the right reduction type llvm-svn: 212126
2014-07-02 04:52:51 +08:00
; CHECK: Reduction Type: NONE
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_sum_12
Introduce reduction types This change is particularly useful in the code generation as we need to know which binary operator/identity element we need to combine/initialize the privatization locations. + Print the reduction type for each memory access + Adjusted the test cases to comply with the new output format and to test for the right reduction type llvm-svn: 212126
2014-07-02 04:52:51 +08:00
; CHECK: Reduction Type: NONE
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
; CHECK: MemRef_sum_04
;
; int f(int * __restrict__ A) {
; int i, j, sum = 1;
; for (i = 0; i < 100; i++) {
; sum *= 7;
; for (j = 0; j < 100; j++) {
; sum += A[i+j];
; }
; }
; return sum;
; }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define i32 @f(i32* noalias %A) {
entry:
%sum.04.reg2mem = alloca i32
%sum.12.reg2mem = alloca i32
br label %entry.split
entry.split: ; preds = %entry
store i32 0, i32* %sum.04.reg2mem
br label %for.body
for.body: ; preds = %for.inc5, %entry.split
%indvars.iv23 = phi i64 [ 0, %entry.split ], [ %3, %for.inc5 ]
Update Polly tests to handle explicitly typed load changes in LLVM. llvm-svn: 230796
2015-02-28 05:22:50 +08:00
%sum.04.reload = load i32, i32* %sum.04.reg2mem
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
%mul = mul nsw i32 %sum.04.reload, 7
store i32 %mul, i32* %sum.12.reg2mem
br label %for.inc
for.inc: ; preds = %for.inc, %for.body
%indvars.iv1 = phi i64 [ 0, %for.body ], [ %1, %for.inc ]
Update Polly tests to handle explicitly typed load changes in LLVM. llvm-svn: 230796
2015-02-28 05:22:50 +08:00
%sum.12.reload = load i32, i32* %sum.12.reg2mem
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
%0 = add i64 %indvars.iv23, %indvars.iv1
Update Polly tests to handle explicitly typed gep changes in LLVM llvm-svn: 230784
2015-02-28 03:20:19 +08:00
%arrayidx = getelementptr i32, i32* %A, i64 %0
Update Polly tests to handle explicitly typed load changes in LLVM. llvm-svn: 230796
2015-02-28 05:22:50 +08:00
%tmp5 = load i32, i32* %arrayidx, align 4
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
%add4 = add nsw i32 %tmp5, %sum.12.reload
%1 = add nuw nsw i64 %indvars.iv1, 1
%exitcond1 = icmp eq i64 %1, 100
store i32 %add4, i32* %sum.12.reg2mem
br i1 %exitcond1, label %for.inc5, label %for.inc
for.inc5: ; preds = %for.inc
Update Polly tests to handle explicitly typed load changes in LLVM. llvm-svn: 230796
2015-02-28 05:22:50 +08:00
%2 = load i32, i32* %sum.12.reg2mem
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
%3 = add nuw nsw i64 %indvars.iv23, 1
%exitcond2 = icmp eq i64 %3, 100
store i32 %2, i32* %sum.04.reg2mem
br i1 %exitcond2, label %for.end7, label %for.body
for.end7: ; preds = %for.inc5
Update Polly tests to handle explicitly typed load changes in LLVM. llvm-svn: 230796
2015-02-28 05:22:50 +08:00
%4 = load i32, i32* %sum.04.reg2mem
Allow multiple reductions per statement Iterate over all store memory accesses and check for valid binary reduction candidate loads by following the operands of the stored value. For each candidate pair we check if they have the same base address and there are no other accesses which may overlap with them. This ensures that no intermediate value can escape into other memory locations or is overwritten at some point. + 17 test cases for reduction detection and reduction dependency modeling llvm-svn: 211957
2014-06-28 04:31:28 +08:00
ret i32 %4
}