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/infeasible-rtc.ll

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

59 lines
1.7 KiB
LLVM
Raw Normal View History

[polly] Introduce -polly-print-* passes to replace -analyze. The `opt -analyze` option only works with the legacy pass manager and might be removed in the future, as explained in llvm.org/PR53733. This patch introduced -polly-print-* passes that print what the pass would print with the `-analyze` option and replaces all uses of `-analyze` in the regression tests. There are two exceptions: `CodeGen\single_loop_param_less_equal.ll` and `CodeGen\loop_with_condition_nested.ll` use `-analyze on the `-loops` pass which is not part of Polly. Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D120782
2022-03-14 21:39:25 +08:00
; RUN: opt %loadPolly -polly-print-detect -disable-output < %s \
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
; RUN: | FileCheck %s -check-prefix=DETECT
[polly] Introduce -polly-print-* passes to replace -analyze. The `opt -analyze` option only works with the legacy pass manager and might be removed in the future, as explained in llvm.org/PR53733. This patch introduced -polly-print-* passes that print what the pass would print with the `-analyze` option and replaces all uses of `-analyze` in the regression tests. There are two exceptions: `CodeGen\single_loop_param_less_equal.ll` and `CodeGen\loop_with_condition_nested.ll` use `-analyze on the `-loops` pass which is not part of Polly. Reviewed By: aeubanks Differential Revision: https://reviews.llvm.org/D120782
2022-03-14 21:39:25 +08:00
; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
; RUN: | FileCheck %s -check-prefix=SCOPS
[SCEVAffinator] Make precise modular math more correct. Integer math in LLVM IR is modular. Integer math in isl is arbitrary-precision. Modeling LLVM IR math correctly in isl requires either adding assumptions that math doesn't actually overflow, or explicitly wrapping the math. However, expressions with the "nsw" flag are special; we can pretend they're arbitrary-precision because it's undefined behavior if the result wraps. SCEV expressions based on IR instructions with an nsw flag also carry an nsw flag (roughly; actually, the real rule is a bit more complicated, but the details don't matter here). Before this patch, SCEV flags were also overloaded with an additional function: the ZExt code was mutating SCEV expressions as a hack to indicate to checkForWrapping that we don't need to add assumptions to the operand of a ZExt; it'll add explicit wrapping itself. This kind of works... the problem is that if anything else ever touches that SCEV expression, it'll get confused by the incorrect flags. Instead, with this patch, we make the decision about whether to explicitly wrap the math a bit earlier, basing the decision purely on the SCEV expression itself, and not its users. Differential Revision: https://reviews.llvm.org/D25287 llvm-svn: 284848
2016-10-22 02:08:02 +08:00
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; DETECT: Valid Region for Scop: test1.header => test1.exit
; SCOPS-NOT: Region: %test1.header---%test1.exit
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
; Verify that we detect this scop, but that, due to an infeasible run-time
; check, we refuse to model it.
[SCEVAffinator] Make precise modular math more correct. Integer math in LLVM IR is modular. Integer math in isl is arbitrary-precision. Modeling LLVM IR math correctly in isl requires either adding assumptions that math doesn't actually overflow, or explicitly wrapping the math. However, expressions with the "nsw" flag are special; we can pretend they're arbitrary-precision because it's undefined behavior if the result wraps. SCEV expressions based on IR instructions with an nsw flag also carry an nsw flag (roughly; actually, the real rule is a bit more complicated, but the details don't matter here). Before this patch, SCEV flags were also overloaded with an additional function: the ZExt code was mutating SCEV expressions as a hack to indicate to checkForWrapping that we don't need to add assumptions to the operand of a ZExt; it'll add explicit wrapping itself. This kind of works... the problem is that if anything else ever touches that SCEV expression, it'll get confused by the incorrect flags. Instead, with this patch, we make the decision about whether to explicitly wrap the math a bit earlier, basing the decision purely on the SCEV expression itself, and not its users. Differential Revision: https://reviews.llvm.org/D25287 llvm-svn: 284848
2016-10-22 02:08:02 +08:00
define void @test(i64* %a) nounwind uwtable {
preheader:
br label %test1.header
test1.header:
%i = phi i56 [ 0, %preheader ], [ %i.1, %test1.header ]
%tmp = zext i56 %i to i64
%A.addr = getelementptr i64, i64* %a, i64 %tmp
%A.load = load i64, i64* %A.addr, align 4
%A.inc = zext i56 %i to i64
%A.val = add nsw i64 %A.load, %A.inc
store i64 %A.val, i64* %A.addr, align 4
%i.1 = add i56 %i, 1
%exitcond = icmp eq i56 %i.1, 0
br i1 %exitcond, label %test1.exit, label %test1.header
test1.exit:
ret void
}
; Old version of the previous test; make sure we compute the trip count
; correctly.
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
[SCEVAffinator] Make precise modular math more correct. Integer math in LLVM IR is modular. Integer math in isl is arbitrary-precision. Modeling LLVM IR math correctly in isl requires either adding assumptions that math doesn't actually overflow, or explicitly wrapping the math. However, expressions with the "nsw" flag are special; we can pretend they're arbitrary-precision because it's undefined behavior if the result wraps. SCEV expressions based on IR instructions with an nsw flag also carry an nsw flag (roughly; actually, the real rule is a bit more complicated, but the details don't matter here). Before this patch, SCEV flags were also overloaded with an additional function: the ZExt code was mutating SCEV expressions as a hack to indicate to checkForWrapping that we don't need to add assumptions to the operand of a ZExt; it'll add explicit wrapping itself. This kind of works... the problem is that if anything else ever touches that SCEV expression, it'll get confused by the incorrect flags. Instead, with this patch, we make the decision about whether to explicitly wrap the math a bit earlier, basing the decision purely on the SCEV expression itself, and not its users. Differential Revision: https://reviews.llvm.org/D25287 llvm-svn: 284848
2016-10-22 02:08:02 +08:00
; SCOPS: { Stmt_header[i0] : 0 <= i0 <= 127 };
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
[SCEVAffinator] Make precise modular math more correct. Integer math in LLVM IR is modular. Integer math in isl is arbitrary-precision. Modeling LLVM IR math correctly in isl requires either adding assumptions that math doesn't actually overflow, or explicitly wrapping the math. However, expressions with the "nsw" flag are special; we can pretend they're arbitrary-precision because it's undefined behavior if the result wraps. SCEV expressions based on IR instructions with an nsw flag also carry an nsw flag (roughly; actually, the real rule is a bit more complicated, but the details don't matter here). Before this patch, SCEV flags were also overloaded with an additional function: the ZExt code was mutating SCEV expressions as a hack to indicate to checkForWrapping that we don't need to add assumptions to the operand of a ZExt; it'll add explicit wrapping itself. This kind of works... the problem is that if anything else ever touches that SCEV expression, it'll get confused by the incorrect flags. Instead, with this patch, we make the decision about whether to explicitly wrap the math a bit earlier, basing the decision purely on the SCEV expression itself, and not its users. Differential Revision: https://reviews.llvm.org/D25287 llvm-svn: 284848
2016-10-22 02:08:02 +08:00
define void @test2([128 x i32]* %a) nounwind uwtable {
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
preheader:
br label %header
header:
%i = phi i7 [ 0, %preheader ], [ %i.1, %header ]
%tmp = zext i7 %i to i64
[SCEVAffinator] Make precise modular math more correct. Integer math in LLVM IR is modular. Integer math in isl is arbitrary-precision. Modeling LLVM IR math correctly in isl requires either adding assumptions that math doesn't actually overflow, or explicitly wrapping the math. However, expressions with the "nsw" flag are special; we can pretend they're arbitrary-precision because it's undefined behavior if the result wraps. SCEV expressions based on IR instructions with an nsw flag also carry an nsw flag (roughly; actually, the real rule is a bit more complicated, but the details don't matter here). Before this patch, SCEV flags were also overloaded with an additional function: the ZExt code was mutating SCEV expressions as a hack to indicate to checkForWrapping that we don't need to add assumptions to the operand of a ZExt; it'll add explicit wrapping itself. This kind of works... the problem is that if anything else ever touches that SCEV expression, it'll get confused by the incorrect flags. Instead, with this patch, we make the decision about whether to explicitly wrap the math a bit earlier, basing the decision purely on the SCEV expression itself, and not its users. Differential Revision: https://reviews.llvm.org/D25287 llvm-svn: 284848
2016-10-22 02:08:02 +08:00
%A.addr = getelementptr [128 x i32], [128 x i32]* %a, i64 0, i64 %tmp
Add test case from llvm.org/PR17187 The new domain construction algorithm now correctly models this test case (and derives an empty run-time condition). Add this test case to ensure we do not regress. llvm-svn: 248669
2015-09-26 22:27:54 +08:00
%A.load = load i32, i32* %A.addr, align 4
%A.inc = zext i7 %i to i32
%A.val = add nsw i32 %A.load, %A.inc
store i32 %A.val, i32* %A.addr, align 4
%i.1 = add i7 %i, 1
%exitcond = icmp eq i7 %i.1, 0
br i1 %exitcond, label %exit, label %header
exit:
ret void
}