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/non-pure-function-calls-cau...

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

138 lines
4.5 KiB
LLVM
Raw Normal View History

Treat conditionally executed non-pure calls as errors This replaces the support for user defined error functions by a heuristic that tries to determine if a call to a non-pure function should be considered "an error". If so the block is assumed not to be executed at runtime. While treating all non-pure function calls as errors will allow a lot more regions to be analyzed, it will also cause us to dismiss a lot again due to an infeasible runtime context. This patch tries to limit that effect. A non-pure function call is considered an error if it is executed only in conditionally with regards to a cheap but simple heuristic. llvm-svn: 249611
2015-10-08 04:32:43 +08:00
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
Make the SCoP generation resistent wrt. error blocks When error blocks are not terminated by an unreachable they have successors that might only be reachable via error blocks. Additionally, branches in error blocks are not checked during SCoP detection, thus we might not be able to handle them. With this patch we do not try to model error block exit conditions. Anything that is only reachable via error blocks is ignored too, as it will not be executed in the optimized version of the SCoP anyway. llvm-svn: 249099
2015-10-02 07:48:18 +08:00
;
ScopInfo: Pass domain constraints through error blocks Previously, we just skipped error blocks during scop construction. With this change we make sure we can construct domains for error blocks such that these domains can be forwarded to subsequent basic blocks. This change ensures that basic blocks that post-dominate and are dominated by a basic block that branches to an error condition have the very same iteration domain as the branching basic block. Before, this change we would construct a domain that excludes all error conditions. Such domains could become _very_ complex and were undesirable to build. Another solution would have been to drop these constraints using a dominance/post-dominance check instead of modeling the error blocks. Such a solution could also work in case of unreachable statements or infinite loops in the scop. However, as we currently (to my believe incorrectly) model unreachable basic blocks in the post-dominance tree, such a solution is not yet feasible and requires first a change to LLVM's post-dominance tree construction. This commit addresses the most sever compile time issue reported in: http://llvm.org/PR25458 llvm-svn: 252713
2015-11-11 16:42:20 +08:00
; Error blocks are skipped during SCoP detection. We skip them during
; SCoP formation too as they might contain instructions we can not handle.
; However statements / basic blocks that follow error blocks are modeled.
Make the SCoP generation resistent wrt. error blocks When error blocks are not terminated by an unreachable they have successors that might only be reachable via error blocks. Additionally, branches in error blocks are not checked during SCoP detection, thus we might not be able to handle them. With this patch we do not try to model error block exit conditions. Anything that is only reachable via error blocks is ignored too, as it will not be executed in the optimized version of the SCoP anyway. llvm-svn: 249099
2015-10-02 07:48:18 +08:00
;
; void timer_start(void);
; void timer_stop(void);
; void kernel(int *A, int *B, int timeit, int N) {
;
; if (timeit) {
; timer_start();
; // split BB
; A[0] = 0; // Do not create a statement for this block
; }
;
; for (int i = 0; i < N; i++)
; A[i] += B[i];
;
; if (timeit) {
; timer_stop();
; if (invalid float branch) // Do not crash on the float branch
; timer_start();
; }
;
; for (int i = 0; i < N; i++)
; A[i] += B[i];
;
; if (timeit)
; timer_stop();
; }
;
[FIX] Carefully simplify assumptions in the presence of error blocks If a SCoP contains error blocks we cannot use the domain constraints to simplify the assumptions as the domain is already influenced by the assumptions we took. Before this patch we did that and some assumptions became self-fulfilling as they were implied by the domain constraints. llvm-svn: 252424
2015-11-09 04:16:39 +08:00
; The assumed context should not be empty even though all statements are
; executed only if timeit != 0.
Make the SCoP generation resistent wrt. error blocks When error blocks are not terminated by an unreachable they have successors that might only be reachable via error blocks. Additionally, branches in error blocks are not checked during SCoP detection, thus we might not be able to handle them. With this patch we do not try to model error block exit conditions. Anything that is only reachable via error blocks is ignored too, as it will not be executed in the optimized version of the SCoP anyway. llvm-svn: 249099
2015-10-02 07:48:18 +08:00
;
; CHECK: Region: %entry.split---%if.end.20
; CHECK: Assumed Context:
Track assumptions and restrictions separatly In order to speed up compile time and to avoid random timeouts we now separately track assumptions and restrictions. In this context assumptions describe parameter valuations we need and restrictions describe parameter valuations we do not allow. During AST generation we create a runtime check for both, whereas the one for the restrictions is negated before a conjunction is build. Except the In-Bounds assumptions we currently only track restrictions. Differential Revision: http://reviews.llvm.org/D17247 llvm-svn: 262328
2016-03-01 21:06:28 +08:00
; CHECK-NEXT: [timeit, N] -> { : }
; CHECK: Invalid Context:
; CHECK-NEXT: [timeit, N] -> { : timeit < 0 or timeit > 0 }
Make the SCoP generation resistent wrt. error blocks When error blocks are not terminated by an unreachable they have successors that might only be reachable via error blocks. Additionally, branches in error blocks are not checked during SCoP detection, thus we might not be able to handle them. With this patch we do not try to model error block exit conditions. Anything that is only reachable via error blocks is ignored too, as it will not be executed in the optimized version of the SCoP anyway. llvm-svn: 249099
2015-10-02 07:48:18 +08:00
; CHECK: Statements {
ScopInfo: Remove domains of error blocks (and blocks they dominate) early on Trying to build up access functions for any of these blocks is likely to fail, as error blocks may contain invalid/non-representable instructions, and blocks dominated by error blocks may reference such instructions, which wil also cause failures. As all of these blocks are anyhow assumed to not be executed, we can just remove them early on. This fixes http://llvm.org/PR25596 llvm-svn: 253818
2015-11-22 19:06:51 +08:00
; CHECK-NOT: Stmt_if_then_split
Make the SCoP generation resistent wrt. error blocks When error blocks are not terminated by an unreachable they have successors that might only be reachable via error blocks. Additionally, branches in error blocks are not checked during SCoP detection, thus we might not be able to handle them. With this patch we do not try to model error block exit conditions. Anything that is only reachable via error blocks is ignored too, as it will not be executed in the optimized version of the SCoP anyway. llvm-svn: 249099
2015-10-02 07:48:18 +08:00
; CHECK: Stmt_for_body
; CHECK: Stmt_for_body_9
; CHECK: }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @kernel(i32* %A, i32* %B, i32 %timeit, i32 %N) {
entry:
br label %entry.split
entry.split:
%tobool = icmp eq i32 %timeit, 0
br i1 %tobool, label %for.cond.pre, label %if.then
if.then: ; preds = %entry
call void @timer_start()
br label %if.then.split
; Dead block if we assume if.then not to be executed because of the call
if.then.split: ; preds = %if.then
%A0 = getelementptr inbounds i32, i32* %A, i64 0
store i32 0, i32* %A0, align 4
br label %for.cond.pre
for.cond.pre:
%tmp = sext i32 %N to i64
br label %for.cond
for.cond: ; preds = %for.inc, %if.end
%indvars.iv1 = phi i64 [ %indvars.iv.next2, %for.inc ], [ 0, %for.cond.pre ]
%cmp = icmp slt i64 %indvars.iv1, %tmp
br i1 %cmp, label %for.body, label %for.end
for.body: ; preds = %for.cond
%arrayidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv1
%tmp3 = load i32, i32* %arrayidx, align 4
%arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv1
%tmp4 = load i32, i32* %arrayidx2, align 4
%add = add nsw i32 %tmp4, %tmp3
store i32 %add, i32* %arrayidx2, align 4
br label %for.inc
for.inc: ; preds = %for.body
%indvars.iv.next2 = add nuw nsw i64 %indvars.iv1, 1
br label %for.cond
for.end: ; preds = %for.cond
%tobool3 = icmp eq i32 %timeit, 0
br i1 %tobool3, label %if.end.5, label %if.then.4
if.then.4: ; preds = %for.end
call void @timer_stop()
%na = fcmp one float 4.0, 5.0
br i1 %na, label %if.end.5, label %if.then.4.rem
if.then.4.rem: ; preds = %for.end
call void @timer_start()
br label %if.end.5
if.end.5: ; preds = %for.end, %if.then.4
%tmp5 = sext i32 %N to i64
br label %for.cond.7
for.cond.7: ; preds = %for.inc.15, %if.end.5
%indvars.iv = phi i64 [ %indvars.iv.next, %for.inc.15 ], [ 0, %if.end.5 ]
%cmp8 = icmp slt i64 %indvars.iv, %tmp5
br i1 %cmp8, label %for.body.9, label %for.end.17
for.body.9: ; preds = %for.cond.7
%arrayidx11 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
%tmp6 = load i32, i32* %arrayidx11, align 4
%arrayidx13 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
%tmp7 = load i32, i32* %arrayidx13, align 4
%add14 = add nsw i32 %tmp7, %tmp6
store i32 %add14, i32* %arrayidx13, align 4
br label %for.inc.15
for.inc.15: ; preds = %for.body.9
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br label %for.cond.7
for.end.17: ; preds = %for.cond.7
%tobool18 = icmp eq i32 %timeit, 0
br i1 %tobool18, label %if.end.20, label %if.then.19
if.then.19: ; preds = %for.end.17
call void @timer_stop()
br label %if.end.20
if.end.20: ; preds = %for.end.17, %if.then.19
ret void
}
declare void @timer_start()
declare void @timer_stop()