This is an archive of the discontinued LLVM Phabricator instance.

Differential D83798

[SCEV] Fix ScalarEvolution tests under NPM
ClosedPublic

Authored by aeubanks on Jul 14 2020, 11:22 AM.

Details

Reviewers
lebedev.ri
hans
ychen
asbirlea
Commits
rG9adbb5cb3a56: [SCEV] Fix ScalarEvolution tests under NPM
Summary

Many tests use opt's -analyze feature, which does not translate well to
NPM and has better alternatives. The alternative here is to explicitly
add a pass that calls ScalarEvolution::print().

The legacy pass manager RUNs aren't changing, but they are now pinned to
the legacy pass manager. For each legacy pass manager RUN, I added a
corresponding NPM RUN using the 'print<scalar-evolution>' pass. For
compatibility with update_analyze_test_checks.py and existing test
CHECKs, 'print<scalar-evolution>' now prints what -analyze prints per
function.

This was generated by the following Python script and failures were
manually fixed up:

import sys
for i in sys.argv:

with open(i, 'r') as f:
    s = f.read()
with open(i, 'w') as f:
    for l in s.splitlines():
        if "RUN:" in l and ' -analyze ' in l and '\\' not in l:
            f.write(l.replace(' -analyze ', ' -analyze -enable-new-pm=0 '))
            f.write('\n')
            f.write(l.replace(' -analyze ', ' -disable-output ').replace(' -scalar-evolution ', ' "-passes=print<scalar-evolution>" ').replace(" | ", " 2>&1 | "))
            f.write('\n')
        else:
            f.write(l)

There are a couple failures still in ScalarEvolution under NPM, but
those are due to other unrelated naming conflicts.

Diff Detail

Event Timeline

aeubanks created this revision.Jul 14 2020, 11:22 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 14 2020, 11:22 AM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
aeubanks added a reviewer: lebedev.ri.Jul 14 2020, 11:22 AM
Harbormaster completed remote builds in B64199: Diff 277914.Jul 14 2020, 11:58 AM
aeubanks updated this revision to Diff 278225.Jul 15 2020, 9:41 AM

rebase

aeubanks added reviewers: hans, ychen.Jul 15 2020, 9:41 AM
ychen added a comment.Jul 15 2020, 9:54 AM

LGTM. Please let one more reviewer double-check.

Harbormaster failed remote builds in B64378: Diff 278225!Jul 15 2020, 10:19 AM
aeubanks updated this revision to Diff 278251.Jul 15 2020, 11:06 AM

Fix tests broken after rebase

Harbormaster failed remote builds in B64391: Diff 278251!Jul 15 2020, 11:41 AM
aeubanks added a reviewer: asbirlea.Jul 15 2020, 2:25 PM
asbirlea accepted this revision.Jul 15 2020, 10:22 PM

Thank you!

This revision is now accepted and ready to land.Jul 15 2020, 10:22 PM
Closed by commit rG9adbb5cb3a56: [SCEV] Fix ScalarEvolution tests under NPM (authored by aeubanks). · Explain WhyJul 16 2020, 11:24 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
lib/
Analysis/
5 lines
test/
Analysis/
ScalarEvolution/
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
4 lines
4 lines
4 lines
4 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
5 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
6 lines
3 lines
3 lines
3 lines
6 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
6 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
4 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines

Diff 278551

llvm/lib/Analysis/ScalarEvolution.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 11,931 Lines • ▼ Show 20 Lines
PreservedAnalyses PreservedAnalyses
ScalarEvolutionVerifierPass::run(Function &F, FunctionAnalysisManager &AM) { ScalarEvolutionVerifierPass::run(Function &F, FunctionAnalysisManager &AM) {
AM.getResult<ScalarEvolutionAnalysis>(F).verify(); AM.getResult<ScalarEvolutionAnalysis>(F).verify();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
PreservedAnalyses PreservedAnalyses
ScalarEvolutionPrinterPass::run(Function &F, FunctionAnalysisManager &AM) { ScalarEvolutionPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
// For compatibility with opt's -analyze feature under legacy pass manager
// which was not ported to NPM. This keeps tests using
// update_analyze_test_checks.py working.
OS << "Printing analysis 'Scalar Evolution Analysis' for function '"
<< F.getName() << "':\n";
AM.getResult<ScalarEvolutionAnalysis>(F).print(OS); AM.getResult<ScalarEvolutionAnalysis>(F).print(OS);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
INITIALIZE_PASS_BEGIN(ScalarEvolutionWrapperPass, "scalar-evolution", INITIALIZE_PASS_BEGIN(ScalarEvolutionWrapperPass, "scalar-evolution",
"Scalar Evolution Analysis", false, true) "Scalar Evolution Analysis", false, true)
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
▲ Show 20 Lines • Show All 525 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/2007-07-15-NegativeStride.ll

; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR1533 ; PR1533
@array = weak global [101 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=1] @array = weak global [101 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=1]
; CHECK: Loop %bb: backedge-taken count is 100 ; CHECK: Loop %bb: backedge-taken count is 100
define void @loop(i32 %x) { define void @loop(i32 %x) {
entry: entry:
Show All 13 Lines

llvm/test/Analysis/ScalarEvolution/2007-08-06-Unsigned.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; PR1597 ; PR1597
; CHECK: Loop %bb: backedge-taken count is (-1 + (-1 * %x) + %y) ; CHECK: Loop %bb: backedge-taken count is (-1 + (-1 * %x) + %y)
define i32 @f(i32 %x, i32 %y) { define i32 @f(i32 %x, i32 %y) {
entry: entry:
%tmp63 = icmp ult i32 %x, %y ; <i1> [#uses=1] %tmp63 = icmp ult i32 %x, %y ; <i1> [#uses=1]
br i1 %tmp63, label %bb.preheader, label %bb8 br i1 %tmp63, label %bb.preheader, label %bb8
Show All 23 Lines

llvm/test/Analysis/ScalarEvolution/2007-09-27-LargeStepping.ll

; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR1706 ; PR1706
; CHECK: backedge-taken count is 13 ; CHECK: backedge-taken count is 13
define i32 @f() { define i32 @f() {
entry: entry:
br label %bb5 br label %bb5
Show All 14 Lines

llvm/test/Analysis/ScalarEvolution/2007-11-18-OrInstruction.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR1810 ; PR1810
define void @fun() { define void @fun() {
entry: entry:
br label %header br label %header
header: header:
%i = phi i32 [ 1, %entry ], [ %i.next, %body ] %i = phi i32 [ 1, %entry ], [ %i.next, %body ]
%cond = icmp eq i32 %i, 10 %cond = icmp eq i32 %i, 10
Show All 12 Lines

llvm/test/Analysis/ScalarEvolution/2008-02-11-ReversedCondition.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; CHECK: Loop %header: backedge-taken count is (0 smax %n) ; CHECK: Loop %header: backedge-taken count is (0 smax %n)
define void @foo(i32 %n) { define void @foo(i32 %n) {
entry: entry:
br label %header br label %header
header: header:
%i = phi i32 [ 0, %entry ], [ %i.inc, %next ] %i = phi i32 [ 0, %entry ], [ %i.inc, %next ]
%cond = icmp sgt i32 %n, %i %cond = icmp sgt i32 %n, %i
br i1 %cond, label %next, label %return br i1 %cond, label %next, label %return
next: next:
%i.inc = add i32 %i, 1 %i.inc = add i32 %i, 1
br label %header br label %header
return: return:
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/2008-02-12-SMAXTripCount.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; PR2002 ; PR2002
; CHECK: Loop %loop: backedge-taken count is (100 + (-100 smax %n)) ; CHECK: Loop %loop: backedge-taken count is (100 + (-100 smax %n))
define void @foo(i8 %n) { define void @foo(i8 %n) {
entry: entry:
br label %loop br label %loop
loop: loop:
%i = phi i8 [ -100, %entry ], [ %i.inc, %next ] %i = phi i8 [ -100, %entry ], [ %i.inc, %next ]
%cond = icmp slt i8 %i, %n %cond = icmp slt i8 %i, %n
br i1 %cond, label %next, label %return br i1 %cond, label %next, label %return
next: next:
%i.inc = add i8 %i, 1 %i.inc = add i8 %i, 1
br label %loop br label %loop
return: return:
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/2008-02-15-UMax.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR2003 ; PR2003
; CHECK: umax ; CHECK: umax
define i32 @foo(i32 %n) { define i32 @foo(i32 %n) {
entry: entry:
br label %header br label %header
header: header:
Show All 10 Lines

llvm/test/Analysis/ScalarEvolution/2008-05-25-NegativeStepToZero.ll

; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2364 ; PR2364
; CHECK: backedge-taken count is 61 ; CHECK: backedge-taken count is 61
define i32 @func_6() nounwind { define i32 @func_6() nounwind {
entry: entry:
br label %bb5 br label %bb5
Show All 14 Lines

llvm/test/Analysis/ScalarEvolution/2008-06-12-BinomialInt64.ll

; RUN: opt < %s -analyze -scalar-evolution 2>/dev/null ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>/dev/null
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>/dev/null
; PR2433 ; PR2433
define i32 @main1(i32 %argc, i8** %argv) nounwind { define i32 @main1(i32 %argc, i8** %argv) nounwind {
entry: entry:
br i1 false, label %bb10, label %bb23 br i1 false, label %bb10, label %bb23
bb10: ; preds = %bb10, %entry bb10: ; preds = %bb10, %entry
%accum.03 = phi i64 [ %tmp14, %bb10 ], [ 0, %entry ] ; <i64> [#uses=1] %accum.03 = phi i64 [ %tmp14, %bb10 ], [ 0, %entry ] ; <i64> [#uses=1]
Show All 34 Lines

llvm/test/Analysis/ScalarEvolution/2008-07-12-UnneededSelect1.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; PR2261 ; PR2261
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'foo' ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'foo'
; CHECK-NOT: smax ; CHECK-NOT: smax
@lut = common global [256 x i8] zeroinitializer, align 32 ; <[256 x i8]*> [#uses=1] @lut = common global [256 x i8] zeroinitializer, align 32 ; <[256 x i8]*> [#uses=1]
define void @foo(i32 %count, i32* %srcptr, i32* %dstptr) nounwind { define void @foo(i32 %count, i32* %srcptr, i32* %dstptr) nounwind {
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/2008-07-12-UnneededSelect2.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; PR2070 ; PR2070
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'a' ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'a'
; CHECK-NOT: smax ; CHECK-NOT: smax
define i32 @a(i32 %x) nounwind { define i32 @a(i32 %x) nounwind {
entry: entry:
icmp sgt i32 %x, 1 ; <i1>:0 [#uses=1] icmp sgt i32 %x, 1 ; <i1>:0 [#uses=1]
Show All 24 Lines

llvm/test/Analysis/ScalarEvolution/2008-07-19-InfiniteLoop.ll

; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2088 ; PR2088
; CHECK: Unpredictable ; CHECK: Unpredictable
define void @fun() { define void @fun() {
entry: entry:
br label %loop br label %loop
loop: loop:
%i = phi i8 [ 0, %entry ], [ %i.next, %loop ] %i = phi i8 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i8 %i, 4 %i.next = add i8 %i, 4
%cond = icmp ne i8 %i.next, 6 %cond = icmp ne i8 %i.next, 6
br i1 %cond, label %loop, label %exit br i1 %cond, label %loop, label %exit
exit: exit:
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/2008-07-19-WrappingIV.ll

; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2088 ; PR2088
; CHECK: backedge-taken count is 113 ; CHECK: backedge-taken count is 113
define void @fun() { define void @fun() {
entry: entry:
br label %loop br label %loop
loop: loop:
%i = phi i8 [ 0, %entry ], [ %i.next, %loop ] %i = phi i8 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i8 %i, 18 %i.next = add i8 %i, 18
%cond = icmp ne i8 %i.next, 4 %cond = icmp ne i8 %i.next, 4
br i1 %cond, label %loop, label %exit br i1 %cond, label %loop, label %exit
exit: exit:
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/2008-07-29-SGTTripCount.ll

; RUN: opt < %s -analyze -scalar-evolution \ ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2607 ; PR2607
define i32 @_Z1aj(i32 %j) nounwind { define i32 @_Z1aj(i32 %j) nounwind {
entry: entry:
icmp sgt i32 0, %j ; <i1>:0 [#uses=1] icmp sgt i32 0, %j ; <i1>:0 [#uses=1]
br i1 %0, label %bb.preheader, label %return br i1 %0, label %bb.preheader, label %return
bb.preheader: ; preds = %entry bb.preheader: ; preds = %entry
Show All 18 Lines

llvm/test/Analysis/ScalarEvolution/2008-07-29-SMinExpr.ll

; RUN: opt < %s -analyze -scalar-evolution \ ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2607 ; PR2607
define i32 @b(i32 %x, i32 %y) nounwind { define i32 @b(i32 %x, i32 %y) nounwind {
entry: entry:
%cmp2 = icmp slt i32 %y, %x %cmp2 = icmp slt i32 %y, %x
%cond3 = select i1 %cmp2, i32 %y, i32 %x %cond3 = select i1 %cmp2, i32 %y, i32 %x
%cmp54 = icmp slt i32 %cond3, -2147483632 %cmp54 = icmp slt i32 %cond3, -2147483632
br i1 %cmp54, label %forinc, label %afterfor br i1 %cmp54, label %forinc, label %afterfor
Show All 16 Lines

llvm/test/Analysis/ScalarEvolution/2008-08-04-IVOverflow.ll

; RUN: opt < %s -analyze -scalar-evolution \ ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2621 ; PR2621
define i32 @a() nounwind { define i32 @a() nounwind {
entry: entry:
br label %bb1 br label %bb1
bb: bb:
trunc i32 %i.0 to i16 trunc i32 %i.0 to i16
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/2008-08-04-LongAddRec.ll

; RUN: opt < %s -analyze -scalar-evolution \ ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR2621 ; PR2621
define i32 @a() nounwind { define i32 @a() nounwind {
entry: entry:
br label %bb1 br label %bb1
bb: ; preds = %bb1 bb: ; preds = %bb1
add i16 %x17.0, 1 ; <i16>:0 [#uses=2] add i16 %x17.0, 1 ; <i16>:0 [#uses=2]
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/2008-11-02-QuadraticCrash.ll

; RUN: opt < %s -analyze -scalar-evolution ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution
; RUN: opt < %s -disable-output -scalar-evolution
; PR1827 ; PR1827
declare void @use(i32) declare void @use(i32)
define void @foo() { define void @foo() {
entry: entry:
br label %loop_1 br label %loop_1
Show All 12 Lines

llvm/test/Analysis/ScalarEvolution/2008-11-15-CubicOOM.ll

; RUN: opt < %s -analyze -scalar-evolution ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution
; RUN: opt < %s -disable-output -scalar-evolution
; PR2602 ; PR2602
define i32 @a() nounwind { define i32 @a() nounwind {
entry: entry:
br label %bb br label %bb
bb: ; preds = %bb, %entry bb: ; preds = %bb, %entry
%w.0 = phi i32 [ 0, %entry ], [ %tmp, %bb ] ; <i32> [#uses=2] %w.0 = phi i32 [ 0, %entry ], [ %tmp, %bb ] ; <i32> [#uses=2]
Show All 10 Lines

llvm/test/Analysis/ScalarEvolution/2008-11-18-LessThanOrEqual.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; CHECK: Loop %bb: backedge-taken count is (7 + (-1 * %argc)) ; CHECK: Loop %bb: backedge-taken count is (7 + (-1 * %argc))
define i32 @main(i32 %argc, i8** %argv) nounwind { define i32 @main(i32 %argc, i8** %argv) nounwind {
entry: entry:
%0 = icmp ugt i32 %argc, 7 ; <i1> [#uses=1] %0 = icmp ugt i32 %argc, 7 ; <i1> [#uses=1]
br i1 %0, label %bb2, label %bb.nph br i1 %0, label %bb2, label %bb.nph
Show All 23 Lines

llvm/test/Analysis/ScalarEvolution/2008-11-18-Stride1.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: Loop %bb: backedge-taken count is ((-5 + %x) /u 3) ; CHECK: Loop %bb: backedge-taken count is ((-5 + %x) /u 3)
; CHECK: Loop %bb: max backedge-taken count is 1431655764 ; CHECK: Loop %bb: max backedge-taken count is 1431655764
; ScalarEvolution can't compute a trip count because it doesn't know if ; ScalarEvolution can't compute a trip count because it doesn't know if
; dividing by the stride will have a remainder. This could theoretically ; dividing by the stride will have a remainder. This could theoretically
; be teaching it how to use a more elaborate trip count computation. ; be teaching it how to use a more elaborate trip count computation.
Show All 29 Lines

llvm/test/Analysis/ScalarEvolution/2008-11-18-Stride2.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; CHECK: Loop %bb: backedge-taken count is ((999 + (-1 * %x)) /u 3) ; CHECK: Loop %bb: backedge-taken count is ((999 + (-1 * %x)) /u 3)
; CHECK: Loop %bb: max backedge-taken count is 334 ; CHECK: Loop %bb: max backedge-taken count is 334
; This is a tricky testcase for unsigned wrap detection which ScalarEvolution ; This is a tricky testcase for unsigned wrap detection which ScalarEvolution
; doesn't yet know how to do. ; doesn't yet know how to do.
Show All 28 Lines

llvm/test/Analysis/ScalarEvolution/2008-12-08-FiniteSGE.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: backedge-taken count is 255 ; CHECK: backedge-taken count is 255
define i32 @foo(i32 %x, i32 %y, i32* %lam, i32* %alp) nounwind { define i32 @foo(i32 %x, i32 %y, i32* %lam, i32* %alp) nounwind {
bb1.thread: bb1.thread:
br label %bb1 br label %bb1
bb1: ; preds = %bb1, %bb1.thread bb1: ; preds = %bb1, %bb1.thread
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/2008-12-11-SMaxOverflow.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: @f ; CHECK: @f
; CHECK: Loop %bb16.preheader: backedge-taken count is (-1 + %c.idx.val) ; CHECK: Loop %bb16.preheader: backedge-taken count is (-1 + %c.idx.val)
define i32 @f(i32 %c.idx.val) { define i32 @f(i32 %c.idx.val) {
bb2: bb2:
%k.018 = add i32 %c.idx.val, -1 ; <i32> [#uses=2] %k.018 = add i32 %c.idx.val, -1 ; <i32> [#uses=2]
Show All 21 Lines

llvm/test/Analysis/ScalarEvolution/2008-12-14-StrideAndSigned.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; XFAIL: * ; XFAIL: *
; CHECK: (((-1 * %i0) + (100005 smax %i0)) /u 5) ; CHECK: (((-1 * %i0) + (100005 smax %i0)) /u 5)
define i32 @foo0(i32 %i0) nounwind { define i32 @foo0(i32 %i0) nounwind {
entry: entry:
br label %bb1 br label %bb1
Show All 14 Lines

llvm/test/Analysis/ScalarEvolution/2008-12-15-DontUseSDiv.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; CHECK: /u 5 ; CHECK: /u 5
define i8 @foo0(i8 %i0) nounwind { define i8 @foo0(i8 %i0) nounwind {
entry: entry:
br label %bb1 br label %bb1
bb: ; preds = %bb1 bb: ; preds = %bb1
Show All 13 Lines

llvm/test/Analysis/ScalarEvolution/2009-01-02-SignedNegativeStride.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR3275 ; PR3275
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'func_15' ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'func_15'
; CHECK-NOT: /u -1 ; CHECK-NOT: /u -1
@g_16 = external global i16 ; <i16*> [#uses=3] @g_16 = external global i16 ; <i16*> [#uses=3]
@.str = external constant [4 x i8] ; <[4 x i8]*> [#uses=0] @.str = external constant [4 x i8] ; <[4 x i8]*> [#uses=0]
Show All 34 Lines

llvm/test/Analysis/ScalarEvolution/2009-04-22-TruncCast.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'test1' ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'test1'
; CHECK-NOT: (trunc i{{.*}}ext ; CHECK-NOT: (trunc i{{.*}}ext
define i16 @test1(i8 %x) { define i16 @test1(i8 %x) {
%A = sext i8 %x to i32 %A = sext i8 %x to i32
%B = trunc i32 %A to i16 %B = trunc i32 %A to i16
ret i16 %B ret i16 %B
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/2009-05-09-PointerEdgeCount.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR3171 ; PR3171
; CHECK: count is 2 ; CHECK: count is 2
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
%struct.Foo = type { i32 } %struct.Foo = type { i32 }
%struct.NonPod = type { [2 x %struct.Foo] } %struct.NonPod = type { [2 x %struct.Foo] }
Show All 22 Lines

llvm/test/Analysis/ScalarEvolution/2009-07-04-GroupConstantsWidthMismatch.ll

; RUN: opt < %s -analyze -scalar-evolution ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution
; RUN: opt < %s -disable-output -scalar-evolution
; PR4501 ; PR4501
define void @test() { define void @test() {
entry: entry:
%0 = load i16, i16* undef, align 1 %0 = load i16, i16* undef, align 1
%1 = lshr i16 %0, 8 %1 = lshr i16 %0, 8
%2 = and i16 %1, 3 %2 = and i16 %1, 3
%3 = zext i16 %2 to i32 %3 = zext i16 %2 to i32
%4 = load i8, i8* undef, align 1 %4 = load i8, i8* undef, align 1
%5 = lshr i8 %4, 4 %5 = lshr i8 %4, 4
%6 = and i8 %5, 1 %6 = and i8 %5, 1
%7 = zext i8 %6 to i32 %7 = zext i8 %6 to i32
%t1 = add i32 %3, %7 %t1 = add i32 %3, %7
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/2010-09-03-RequiredTransitive.ll

; RUN: opt -indvars -scalar-evolution -analyze < %s | FileCheck %s ; RUN: opt -indvars -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
; RUN: opt "-passes=loop(indvars),print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
; This test checks if the SCEV analysis is printed out at all. ; This test checks if the SCEV analysis is printed out at all.
; It failed once as the RequiredTransitive option was not implemented ; It failed once as the RequiredTransitive option was not implemented
; correctly. ; correctly.
; CHECK: Classifying expressions for: @main ; CHECK: Classifying expressions for: @main
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/2011-04-26-FoldAddRec.ll

; RUN: opt < %s -analyze -iv-users ; RUN: opt < %s -analyze -enable-new-pm=0 -iv-users
; RUN: opt < %s -disable-output -iv-users
; RUN: opt < %s -passes='print<iv-users>' ; RUN: opt < %s -passes='print<iv-users>'
; PR9633: Tests that SCEV handles the mul.i2 recurrence being folded to ; PR9633: Tests that SCEV handles the mul.i2 recurrence being folded to
; constant zero. ; constant zero.
define signext i8 @func_14(i8 signext %p_18) nounwind readnone ssp { define signext i8 @func_14(i8 signext %p_18) nounwind readnone ssp {
entry: entry:
br label %for.inc br label %for.inc
Show All 25 Lines

llvm/test/Analysis/ScalarEvolution/2011-10-04-ConstEvolve.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; Exercise getConstantEvolvingPHIOperands on an interesting loop. ; Exercise getConstantEvolvingPHIOperands on an interesting loop.
; This should complete in milliseconds, not minutes. ; This should complete in milliseconds, not minutes.
; Just check that it actually ran trip count analysis. ; Just check that it actually ran trip count analysis.
; CHECK: Determining loop execution counts for: @test ; CHECK: Determining loop execution counts for: @test
define void @test() nounwind { define void @test() nounwind {
entry: entry:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/SolveQuadraticEquation.ll

; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 2>&1 | FileCheck %s
; PR1101 ; PR1101
@A = weak global [1000 x i32] zeroinitializer, align 32 @A = weak global [1000 x i32] zeroinitializer, align 32
define void @test1(i32 %N) { define void @test1(i32 %N) {
entry: entry:
%"alloca point" = bitcast i32 0 to i32 ; <i32> [#uses=0] %"alloca point" = bitcast i32 0 to i32 ; <i32> [#uses=0]
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/ZeroStep.ll

; RUN: opt -analyze -scalar-evolution < %s -o - -S | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s -o - -S | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s -o - -S 2>&1 | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Test that SCEV is capable of figuring out value of 'IV' that actually does not change. ; Test that SCEV is capable of figuring out value of 'IV' that actually does not change.
; CHECK: Classifying expressions for: @foo ; CHECK: Classifying expressions for: @foo
; CHECK: %iv.i = phi i64 ; CHECK: %iv.i = phi i64
; CHECK: -5 U: [-5,-4) S: [-5,-4) Exits: -5 LoopDispositions: { %loop: Invariant } ; CHECK: -5 U: [-5,-4) S: [-5,-4) Exits: -5 LoopDispositions: { %loop: Invariant }
Show All 9 Lines

llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; Reduced from test-suite/MultiSource/Benchmarks/MiBench/office-ispell/correct.c ; Reduced from test-suite/MultiSource/Benchmarks/MiBench/office-ispell/correct.c
; getelementptr, obviously, takes pointer as it's base, and returns a pointer. ; getelementptr, obviously, takes pointer as it's base, and returns a pointer.
; SCEV operands are sorted in hope that it increases folding potential, ; SCEV operands are sorted in hope that it increases folding potential,
; and at the same time SCEVAddExpr's type is the type of the last(!) operand. ; and at the same time SCEVAddExpr's type is the type of the last(!) operand.
; Which means, in some exceedingly rare cases, pointer operand may happen to ; Which means, in some exceedingly rare cases, pointer operand may happen to
; end up not being the last operand, and as a result SCEV for GEP will suddenly ; end up not being the last operand, and as a result SCEV for GEP will suddenly
; have a non-pointer return type. We should ensure that does not happen. ; have a non-pointer return type. We should ensure that does not happen.
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/add-like-or.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
define i8 @or-of-constant-with-no-common-bits-set(i8 %x, i8 %y) { define i8 @or-of-constant-with-no-common-bits-set(i8 %x, i8 %y) {
; CHECK-LABEL: 'or-of-constant-with-no-common-bits-set' ; CHECK-LABEL: 'or-of-constant-with-no-common-bits-set'
; CHECK-NEXT: Classifying expressions for: @or-of-constant-with-no-common-bits-set ; CHECK-NEXT: Classifying expressions for: @or-of-constant-with-no-common-bits-set
; CHECK-NEXT: %t0 = shl i8 %x, 2 ; CHECK-NEXT: %t0 = shl i8 %x, 2
; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125) ; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125)
; CHECK-NEXT: %r = or i8 %t0, 3 ; CHECK-NEXT: %r = or i8 %t0, 3
; CHECK-NEXT: --> (3 + (4 * %x))<nuw><nsw> U: [3,0) S: [-125,-128) ; CHECK-NEXT: --> (3 + (4 * %x))<nuw><nsw> U: [3,0) S: [-125,-128)
; CHECK-NEXT: Determining loop execution counts for: @or-of-constant-with-no-common-bits-set ; CHECK-NEXT: Determining loop execution counts for: @or-of-constant-with-no-common-bits-set
; ;
%t0 = shl i8 %x, 2 %t0 = shl i8 %x, 2
%r = or i8 %t0, 3 %r = or i8 %t0, 3
ret i8 %r ret i8 %r
} }

llvm/test/Analysis/ScalarEvolution/and-xor.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
; CHECK: --> (zext ; CHECK: --> (zext
; CHECK: --> (zext ; CHECK: --> (zext
; CHECK-NOT: --> (zext ; CHECK-NOT: --> (zext
define i32 @test1(i32 %x) { define i32 @test1(i32 %x) {
%n = and i32 %x, 255 %n = and i32 %x, 255
Show All 32 Lines

llvm/test/Analysis/ScalarEvolution/avoid-assume-hang.ll

; RUN: opt %s -always-inline | opt -analyze -scalar-evolution ; RUN: opt %s -always-inline | opt -analyze -enable-new-pm=0 -scalar-evolution
; RUN: opt %s -always-inline 2>&1 | opt -disable-output -scalar-evolution
; There was optimization bug in ScalarEvolution, that causes too long ; There was optimization bug in ScalarEvolution, that causes too long
; compute time and stack overflow crash. ; compute time and stack overflow crash.
declare void @body(i32) declare void @body(i32)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define available_externally void @assume1(i64 %i.ext, i64 %a) alwaysinline { define available_externally void @assume1(i64 %i.ext, i64 %a) alwaysinline {
%cmp0 = icmp ne i64 %i.ext, %a %cmp0 = icmp ne i64 %i.ext, %a
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Linesloop:
%i.next = add i64 %i.ext, 1 %i.next = add i64 %i.ext, 1
%next = trunc i64 %i.next to i32 %next = trunc i64 %i.next to i32
%done = icmp eq i32 %i, 500000000 %done = icmp eq i32 %i, 500000000
br i1 %done, label %exit, label %loop br i1 %done, label %exit, label %loop
exit: exit:
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/ScalarEvolution/avoid-infinite-recursion-0.ll

; RUN: opt < %s -analyze -scalar-evolution ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution
; RUN: opt < %s -disable-output -scalar-evolution
; PR4537 ; PR4537
; ModuleID = 'b.bc' ; ModuleID = 'b.bc'
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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i32 @test() { define i32 @test() {
entry: entry:
Show All 21 Lines

llvm/test/Analysis/ScalarEvolution/avoid-smax-0.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; CHECK: Loop %bb3: backedge-taken count is (-1 + %n) ; CHECK: Loop %bb3: backedge-taken count is (-1 + %n)
; We don't want to use a max in the trip count expression in ; We don't want to use a max in the trip count expression in
; this testcase. ; this testcase.
define void @foo(i32 %n, i32* %p, i32* %q) nounwind { define void @foo(i32 %n, i32* %p, i32* %q) nounwind {
entry: entry:
Show All 28 Lines

llvm/test/Analysis/ScalarEvolution/avoid-smax-1.ll

; RUN: opt < %s -analyze -scalar-evolution -S | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -S | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -S 2>&1 | FileCheck %s
; Indvars should be able to find the trip count for the bb6 loop ; Indvars should be able to find the trip count for the bb6 loop
; without using a maximum calculation (icmp, select) because it should ; without using a maximum calculation (icmp, select) because it should
; be able to prove that the comparison is guarded by an appropriate ; be able to prove that the comparison is guarded by an appropriate
; conditional branch. Unfortunately, indvars is not yet able to find ; conditional branch. Unfortunately, indvars is not yet able to find
; the comparison for the other two loops in this testcase. ; the comparison for the other two loops in this testcase.
; ;
; CHECK: Loop %bb6: backedge-taken count is (-1 + %w) ; CHECK: Loop %bb6: backedge-taken count is (-1 + %w)
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/binomial-explision.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
; Check that we don't have unreasonably huge SCEVs and in particular only a ; Check that we don't have unreasonably huge SCEVs and in particular only a
; reasonable amount of AddRecs in the notation of %tmp19. If we "simplify" SCEVs ; reasonable amount of AddRecs in the notation of %tmp19. If we "simplify" SCEVs
; too aggressively, we may end up with huge nested expressions. ; too aggressively, we may end up with huge nested expressions.
define void @test(i32 %x, i64 %y, i1 %cond) { define void @test(i32 %x, i64 %y, i1 %cond) {
Show All 38 Lines

llvm/test/Analysis/ScalarEvolution/constant_condition.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define i32 @branch_true(i32 %x, i32 %y) { define i32 @branch_true(i32 %x, i32 %y) {
; CHECK-LABEL: Classifying expressions for: @branch_true ; CHECK-LABEL: Classifying expressions for: @branch_true
entry: entry:
br i1 true, label %add, label %merge br i1 true, label %add, label %merge
add: add:
%sum = add i32 %x, %y %sum = add i32 %x, %y
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/different-loops-recs.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; This test set ensures that we can correctly operate with recurrencies from ; This test set ensures that we can correctly operate with recurrencies from
; different loops. ; different loops.
; Check that we can evaluate a sum of phis from two different loops in any ; Check that we can evaluate a sum of phis from two different loops in any
; order. ; order.
define void @test_00() { define void @test_00() {
▲ Show 20 Lines • Show All 623 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/div-overflow.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; CHECK: --> ((-128 * %a) /u -128) ; CHECK: --> ((-128 * %a) /u -128)
; Don't let ScalarEvolution fold this div away. ; Don't let ScalarEvolution fold this div away.
define i8 @foo(i8 %a) { define i8 @foo(i8 %a) {
%t0 = shl i8 %a, 7 %t0 = shl i8 %a, 7
%t1 = lshr i8 %t0, 7 %t1 = lshr i8 %t0, 7
ret i8 %t1 ret i8 %t1
} }

llvm/test/Analysis/ScalarEvolution/do-loop.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR1614 ; PR1614
; CHECK: smax ; CHECK: smax
define i32 @f(i32 %x, i32 %y) { define i32 @f(i32 %x, i32 %y) {
entry: entry:
br label %bb br label %bb
Show All 11 Lines

llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll

; RUN: opt -analyze -scalar-evolution %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" %s 2>&1 | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @test_and(i16 %in) { define void @test_and(i16 %in) {
br label %bb2 br label %bb2
bb2: ; preds = %bb1.i, %bb2, %0 bb2: ; preds = %bb1.i, %bb2, %0
%_tmp44.i = icmp slt i16 %in, 2 %_tmp44.i = icmp slt i16 %in, 2
Show All 40 Lines

llvm/test/Analysis/ScalarEvolution/exact_iter_count.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; One side exit dominating the latch, exact backedge taken count is known. ; One side exit dominating the latch, exact backedge taken count is known.
define void @test_01() { define void @test_01() {
; CHECK-LABEL: Determining loop execution counts for: @test_01 ; CHECK-LABEL: Determining loop execution counts for: @test_01
; CHECK-NEXT: Loop %loop: <multiple exits> backedge-taken count is 50 ; CHECK-NEXT: Loop %loop: <multiple exits> backedge-taken count is 50
entry: entry:
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/exhaustive-trip-counts.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f_0() { define void @f_0() {
; CHECK-LABEL: Printing analysis 'Scalar Evolution Analysis' for function 'f_0': ; CHECK-LABEL: Printing analysis 'Scalar Evolution Analysis' for function 'f_0':
; CHECK: Loop %for.body: backedge-taken count is 5 ; CHECK: Loop %for.body: backedge-taken count is 5
; CHECK: Loop %for.body: max backedge-taken count is 5 ; CHECK: Loop %for.body: max backedge-taken count is 5
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/exponential-behavior.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f': ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f':
; CHECK: Loop %loop: <multiple exits> Unpredictable backedge-taken count. ; CHECK: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %loop: max backedge-taken count is 0 ; CHECK: Loop %loop: max backedge-taken count is 0
; CHECK: Loop %loop: Unpredictable predicated backedge-taken count. ; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/extract-highbits-sameconstmask.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; The obvious case. ; The obvious case.
define i32 @div(i32 %val) nounwind { define i32 @div(i32 %val) nounwind {
; CHECK-LABEL: 'div' ; CHECK-LABEL: 'div'
; CHECK-NEXT: Classifying expressions for: @div ; CHECK-NEXT: Classifying expressions for: @div
; CHECK-NEXT: %tmp1 = udiv i32 %val, 16 ; CHECK-NEXT: %tmp1 = udiv i32 %val, 16
; CHECK-NEXT: --> (%val /u 16) U: [0,268435456) S: [0,268435456) ; CHECK-NEXT: --> (%val /u 16) U: [0,268435456) S: [0,268435456)
; CHECK-NEXT: %tmp2 = mul i32 %tmp1, 16 ; CHECK-NEXT: %tmp2 = mul i32 %tmp1, 16
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/extract-highbits-variablemask.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; These testcases aren't *identical* but they have the same/similar meaning. ; These testcases aren't *identical* but they have the same/similar meaning.
; The obvious case. ; The obvious case.
define i32 @div(i32 %val, i32 %num) nounwind { define i32 @div(i32 %val, i32 %num) nounwind {
; CHECK-LABEL: 'div' ; CHECK-LABEL: 'div'
; CHECK-NEXT: Classifying expressions for: @div ; CHECK-NEXT: Classifying expressions for: @div
; CHECK-NEXT: %tmp1 = udiv i32 %val, %num ; CHECK-NEXT: %tmp1 = udiv i32 %val, %num
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/extract-lowbits-sameconstmask.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; The obvious case. ; The obvious case.
define i32 @mul(i32 %val) nounwind { define i32 @mul(i32 %val) nounwind {
; CHECK-LABEL: 'mul' ; CHECK-LABEL: 'mul'
; CHECK-NEXT: Classifying expressions for: @mul ; CHECK-NEXT: Classifying expressions for: @mul
; CHECK-NEXT: %tmp1 = mul i32 %val, 16 ; CHECK-NEXT: %tmp1 = mul i32 %val, 16
; CHECK-NEXT: --> (16 * %val) U: [0,-15) S: [-2147483648,2147483633) ; CHECK-NEXT: --> (16 * %val) U: [0,-15) S: [-2147483648,2147483633)
; CHECK-NEXT: %tmp2 = udiv i32 %tmp1, 16 ; CHECK-NEXT: %tmp2 = udiv i32 %tmp1, 16
Show All 38 Lines

llvm/test/Analysis/ScalarEvolution/extract-lowbits-variablemask.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; These testcases aren't *identical* but they have the same/similar meaning. ; These testcases aren't *identical* but they have the same/similar meaning.
; The obvious case. ; The obvious case.
define i32 @mul(i32 %val, i32 %num) nounwind { define i32 @mul(i32 %val, i32 %num) nounwind {
; CHECK-LABEL: 'mul' ; CHECK-LABEL: 'mul'
; CHECK-NEXT: Classifying expressions for: @mul ; CHECK-NEXT: Classifying expressions for: @mul
; CHECK-NEXT: %tmp1 = mul i32 %val, %num ; CHECK-NEXT: %tmp1 = mul i32 %val, %num
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/flags-from-poison-dbg.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; Make sure poison value tracking works in the presence of @llvm.dbg ; Make sure poison value tracking works in the presence of @llvm.dbg
; intrinsics. Unfortunately, I was not able to reduce this file ; intrinsics. Unfortunately, I was not able to reduce this file
; further while still keeping the debug info well formed. ; further while still keeping the debug info well formed.
define void @foo(i32 %n, i32* %arr) !dbg !7 { define void @foo(i32 %n, i32* %arr) !dbg !7 {
; CHECK-LABEL: Classifying expressions for: @foo ; CHECK-LABEL: Classifying expressions for: @foo
entry: entry:
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll

; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; Positive and negative tests for inferring flags like nsw from ; Positive and negative tests for inferring flags like nsw from
; reasoning about how a poison value from overflow would trigger ; reasoning about how a poison value from overflow would trigger
; undefined behavior. ; undefined behavior.
define void @foo() { define void @foo() {
ret void ret void
} }
▲ Show 20 Lines • Show All 860 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/flattened-0.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
define void @foo([7 x i8]* %a) { define void @foo([7 x i8]* %a) {
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
entry: entry:
br label %bb br label %bb
bb: bb:
%idx = phi i64 [ 0, %entry ], [ %idx.incr, %bb ] %idx = phi i64 [ 0, %entry ], [ %idx.incr, %bb ]
Show All 13 Lines

llvm/test/Analysis/ScalarEvolution/fold.ll

; RUN: opt -analyze -scalar-evolution -S < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
define i16 @test1(i8 %x) { define i16 @test1(i8 %x) {
%A = zext i8 %x to i12 %A = zext i8 %x to i12
%B = sext i12 %A to i16 %B = sext i12 %A to i16
; CHECK: zext i8 %x to i16 ; CHECK: zext i8 %x to i16
ret i16 %B ret i16 %B
} }
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/how-far-to-zero.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR13228 ; PR13228
define void @f() nounwind uwtable readnone { define void @f() nounwind uwtable readnone {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.cond, %entry for.cond: ; preds = %for.cond, %entry
%c.0 = phi i8 [ 1, %entry ], [ 0, %for.cond ] %c.0 = phi i8 [ 1, %entry ], [ 0, %for.cond ]
Show All 18 Lines

llvm/test/Analysis/ScalarEvolution/huge_expression_limit.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-huge-expr-threshold=1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-huge-expr-threshold=1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-huge-expr-threshold=1 2>&1 | FileCheck %s
define void @test(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) { define void @test(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) {
; CHECK-LABEL: 'test' ; CHECK-LABEL: 'test'
; CHECK-NEXT: Classifying expressions for: @test ; CHECK-NEXT: Classifying expressions for: @test
; CHECK-NEXT: %add1 = add i32 %a, %b ; CHECK-NEXT: %add1 = add i32 %a, %b
; CHECK-NEXT: --> (%a + %b) U: full-set S: full-set ; CHECK-NEXT: --> (%a + %b) U: full-set S: full-set
; CHECK-NEXT: %add2 = add i32 %add1, %c ; CHECK-NEXT: %add2 = add i32 %add1, %c
; CHECK-NEXT: --> ((%a + %b) + %c) U: full-set S: full-set ; CHECK-NEXT: --> ((%a + %b) + %c) U: full-set S: full-set
Show All 31 Lines

llvm/test/Analysis/ScalarEvolution/implied-via-division.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
define void @test_1(i32 %n) nounwind { define void @test_1(i32 %n) nounwind {
; Prove that (n > 1) ===> (n / 2 > 0). ; Prove that (n > 1) ===> (n / 2 > 0).
; CHECK: Determining loop execution counts for: @test_1 ; CHECK: Determining loop execution counts for: @test_1
; CHECK: Loop %header: backedge-taken count is (-1 + %n.div.2)<nsw> ; CHECK: Loop %header: backedge-taken count is (-1 + %n.div.2)<nsw>
entry: entry:
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/incorrect-nsw.ll

; RUN: opt -analyze -scalar-evolution -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>,print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @bad.nsw() { define void @bad.nsw() {
; CHECK-LABEL: Classifying expressions for: @bad.nsw ; CHECK-LABEL: Classifying expressions for: @bad.nsw
; CHECK-LABEL: Classifying expressions for: @bad.nsw ; CHECK-LABEL: Classifying expressions for: @bad.nsw
entry: entry:
br label %loop br label %loop
loop: loop:
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @f0(i1 %c) { define void @f0(i1 %c) {
; CHECK-LABEL: Classifying expressions for: @f0 ; CHECK-LABEL: Classifying expressions for: @f0
entry: entry:
%start = select i1 %c, i32 127, i32 0 %start = select i1 %c, i32 127, i32 0
%step = select i1 %c, i32 -1, i32 1 %step = select i1 %c, i32 -1, i32 1
br label %loop br label %loop
▲ Show 20 Lines • Show All 238 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/infer-prestart-no-wrap.ll

; ; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @infer.sext.0(i1* %c, i32 %start, i32* %buf) { define void @infer.sext.0(i1* %c, i32 %start, i32* %buf) {
; CHECK-LABEL: Classifying expressions for: @infer.sext.0 ; CHECK-LABEL: Classifying expressions for: @infer.sext.0
entry: entry:
br label %loop br label %loop
loop: loop:
%counter = phi i32 [ 0, %entry ], [ %counter.inc, %loop ] %counter = phi i32 [ 0, %entry ], [ %counter.inc, %loop ]
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/inner-loop-by-latch-cond-unknown.ll

; RUN: opt < %s -analyze -iv-users -S | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -iv-users -S | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<iv-users>" -S 2>&1 | FileCheck %s
; This is a regression test for the commit rL327362. ; This is a regression test for the commit rL327362.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @test(i64 %a, i64* %p) { define void @test(i64 %a, i64* %p) {
entry: entry:
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/limit-depth.ll

; RUN: opt -scalar-evolution-max-arith-depth=0 -scalar-evolution-max-cast-depth=0 -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -scalar-evolution-max-arith-depth=0 -scalar-evolution-max-cast-depth=0 -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -scalar-evolution-max-arith-depth=0 -scalar-evolution-max-cast-depth=0 -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; Check that depth set to 0 prevents getAddExpr and getMulExpr from making ; Check that depth set to 0 prevents getAddExpr and getMulExpr from making
; transformations in SCEV. We expect the result to be very straightforward. ; transformations in SCEV. We expect the result to be very straightforward.
define void @test_add(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) { define void @test_add(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) {
; CHECK-LABEL: @test_add ; CHECK-LABEL: @test_add
; CHECK: %s2 = add i32 %s1, %p3 ; CHECK: %s2 = add i32 %s1, %p3
; CHECK-NEXT: --> (%a + %a + %b + %b + %c + %c + %d + %d + %e + %e + %f + %f) ; CHECK-NEXT: --> (%a + %a + %b + %b + %c + %c + %d + %d + %e + %e + %f + %f)
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/load-with-range-metadata.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define i32 @slt_trip_count_with_range(i32 *%ptr0, i32 *%ptr1) { define i32 @slt_trip_count_with_range(i32 *%ptr0, i32 *%ptr1) {
; CHECK-LABEL: slt_trip_count_with_range ; CHECK-LABEL: slt_trip_count_with_range
entry: entry:
%limit = load i32, i32* %ptr0, !range !0 %limit = load i32, i32* %ptr0, !range !0
br label %loop br label %loop
loop: loop:
Show All 28 Lines

llvm/test/Analysis/ScalarEvolution/load.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
target triple = "i386-pc-linux-gnu" target triple = "i386-pc-linux-gnu"
@arr1 = internal unnamed_addr constant [50 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50], align 4 @arr1 = internal unnamed_addr constant [50 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50], align 4
@arr2 = internal unnamed_addr constant [50 x i32] [i32 49, i32 48, i32 47, i32 46, i32 45, i32 44, i32 43, i32 42, i32 41, i32 40, i32 39, i32 38, i32 37, i32 36, i32 35, i32 34, i32 33, i32 32, i32 31, i32 30, i32 29, i32 28, i32 27, i32 26, i32 25, i32 24, i32 23, i32 22, i32 21, i32 20, i32 19, i32 18, i32 17, i32 16, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0], align 4 @arr2 = internal unnamed_addr constant [50 x i32] [i32 49, i32 48, i32 47, i32 46, i32 45, i32 44, i32 43, i32 42, i32 41, i32 40, i32 39, i32 38, i32 37, i32 36, i32 35, i32 34, i32 33, i32 32, i32 31, i32 30, i32 29, i32 28, i32 27, i32 26, i32 25, i32 24, i32 23, i32 22, i32 21, i32 20, i32 19, i32 18, i32 17, i32 16, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0], align 4
; PR11034 ; PR11034
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/lshr-shl-differentconstmask.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; The obvious case. ; The obvious case.
define i32 @udiv_biggerLshr(i32 %val) nounwind { define i32 @udiv_biggerLshr(i32 %val) nounwind {
; CHECK-LABEL: 'udiv_biggerLshr' ; CHECK-LABEL: 'udiv_biggerLshr'
; CHECK-NEXT: Classifying expressions for: @udiv_biggerLshr ; CHECK-NEXT: Classifying expressions for: @udiv_biggerLshr
; CHECK-NEXT: %tmp1 = udiv i32 %val, 64 ; CHECK-NEXT: %tmp1 = udiv i32 %val, 64
; CHECK-NEXT: --> (%val /u 64) U: [0,67108864) S: [0,67108864) ; CHECK-NEXT: --> (%val /u 64) U: [0,67108864) S: [0,67108864)
; CHECK-NEXT: %tmp2 = mul i32 %tmp1, 16 ; CHECK-NEXT: %tmp2 = mul i32 %tmp1, 16
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/max-addops-inline.ll

; RUN: opt -analyze -scalar-evolution -scev-addops-inline-threshold=1 < %s | FileCheck --check-prefix=CHECK1 %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-addops-inline-threshold=1 < %s | FileCheck --check-prefix=CHECK1 %s
; RUN: opt -analyze -scalar-evolution -scev-addops-inline-threshold=10 < %s | FileCheck --check-prefix=CHECK10 %s ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-addops-inline-threshold=1 < %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-addops-inline-threshold=10 < %s | FileCheck --check-prefix=CHECK10 %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-addops-inline-threshold=10 < %s 2>&1 | FileCheck --check-prefix=CHECK10 %s
define i32 @foo(i64 %p0, i32 %p1) { define i32 @foo(i64 %p0, i32 %p1) {
; CHECK1: %add2 = add nsw i32 %mul1, %add ; CHECK1: %add2 = add nsw i32 %mul1, %add
; CHECK1-NEXT: --> ((trunc i64 %p0 to i32) * (1 + (trunc i64 %p0 to i32)) * (1 + %p1)) ; CHECK1-NEXT: --> ((trunc i64 %p0 to i32) * (1 + (trunc i64 %p0 to i32)) * (1 + %p1))
; CHECK10: %add2 = add nsw i32 %mul1, %add ; CHECK10: %add2 = add nsw i32 %mul1, %add
; CHECK10-NEXT: --> ((trunc i64 %p0 to i32) * (1 + ((trunc i64 %p0 to i32) * (1 + %p1)) + %p1)) ; CHECK10-NEXT: --> ((trunc i64 %p0 to i32) * (1 + ((trunc i64 %p0 to i32) * (1 + %p1)) + %p1))
entry: entry:
%tr = trunc i64 %p0 to i32 %tr = trunc i64 %p0 to i32
%mul = mul nsw i32 %tr, %p1 %mul = mul nsw i32 %tr, %p1
%add = add nsw i32 %mul, %tr %add = add nsw i32 %mul, %tr
%mul1 = mul nsw i32 %add, %tr %mul1 = mul nsw i32 %add, %tr
%add2 = add nsw i32 %mul1, %add %add2 = add nsw i32 %mul1, %add
ret i32 %add2 ret i32 %add2
} }

llvm/test/Analysis/ScalarEvolution/max-addrec-size.ll

; RUN: opt -analyze -scalar-evolution -scalar-evolution-max-add-rec-size=3 < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-add-rec-size=3 < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-add-rec-size=3 < %s 2>&1 | FileCheck %s
; Show that we are able to avoid creation of huge SCEVs by capping the max ; Show that we are able to avoid creation of huge SCEVs by capping the max
; AddRec size. ; AddRec size.
define i32 @test_01(i32 %a, i32 %b) { define i32 @test_01(i32 %a, i32 %b) {
; CHECK-LABEL: Classifying expressions for: @test_01 ; CHECK-LABEL: Classifying expressions for: @test_01
; CHECK-NEXT: %iv = phi i32 [ %a, %entry ], [ %iv.next, %loop ] ; CHECK-NEXT: %iv = phi i32 [ %a, %entry ], [ %iv.next, %loop ]
; CHECK-NEXT: --> {%a,+,%b}<%loop> U: full-set S: full-set ; CHECK-NEXT: --> {%a,+,%b}<%loop> U: full-set S: full-set
Show All 24 Lines

llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Previously in this case the max backedge count would be computed as 1/0, which ; Previously in this case the max backedge count would be computed as 1/0, which
; is correct but undesirable. It would also not fold as a constant, tripping ; is correct but undesirable. It would also not fold as a constant, tripping
; asserts in SCEV. ; asserts in SCEV.
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/max-expr-cache.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; SCEV would take a long time to compute SCEV expressions for this IR. If SCEV ; SCEV would take a long time to compute SCEV expressions for this IR. If SCEV
; finishes in < 1 second then the bug is fixed. ; finishes in < 1 second then the bug is fixed.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64--linux-gnu" target triple = "x86_64--linux-gnu"
define void @smax(i32 %tmp3) { define void @smax(i32 %tmp3) {
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/max-mulops-inline.ll

; RUN: opt -analyze -scalar-evolution -scev-mulops-inline-threshold=1 < %s | FileCheck --check-prefix=CHECK1 %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-mulops-inline-threshold=1 < %s | FileCheck --check-prefix=CHECK1 %s
; RUN: opt -analyze -scalar-evolution -scev-mulops-inline-threshold=10 < %s | FileCheck --check-prefix=CHECK10 %s ; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-mulops-inline-threshold=1 < %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -scev-mulops-inline-threshold=10 < %s | FileCheck --check-prefix=CHECK10 %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -scev-mulops-inline-threshold=10 < %s 2>&1 | FileCheck --check-prefix=CHECK10 %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@a = local_unnamed_addr global i32 0, align 4 @a = local_unnamed_addr global i32 0, align 4
@b = local_unnamed_addr global i32 0, align 4 @b = local_unnamed_addr global i32 0, align 4
define i32 @main() local_unnamed_addr { define i32 @main() local_unnamed_addr {
Show All 19 Lines

llvm/test/Analysis/ScalarEvolution/max-trip-count-address-space.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; ScalarEvolution should be able to understand the loop and eliminate the casts. ; ScalarEvolution should be able to understand the loop and eliminate the casts.
target datalayout = "e-p:32:32:32-p1:16:16:16-p2:8:8:8-p4:64:64:64-n16:32:64" target datalayout = "e-p:32:32:32-p1:16:16:16-p2:8:8:8-p4:64:64:64-n16:32:64"
; CHECK: {%d,+,4}<%bb>{{ U: [^ ]+ S: [^ ]+}}{{ *}} Exits: (-4 + (4 * (trunc i32 %n to i16)) + %d) ; CHECK: {%d,+,4}<%bb>{{ U: [^ ]+ S: [^ ]+}}{{ *}} Exits: (-4 + (4 * (trunc i32 %n to i16)) + %d)
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/max-trip-count.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; ScalarEvolution should be able to understand the loop and eliminate the casts. ; ScalarEvolution should be able to understand the loop and eliminate the casts.
; CHECK: {%d,+,4} ; CHECK: {%d,+,4}
define void @foo(i32* nocapture %d, i32 %n) nounwind { define void @foo(i32* nocapture %d, i32 %n) nounwind {
entry: entry:
%0 = icmp sgt i32 %n, 0 ; <i1> [#uses=1] %0 = icmp sgt i32 %n, 0 ; <i1> [#uses=1]
▲ Show 20 Lines • Show All 424 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/merge-add-rec-many-inputs.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; Check that isImpliedViaMerge wouldn't crash when trying to prove ; Check that isImpliedViaMerge wouldn't crash when trying to prove
; SCEVUnknown and AddRec with phi having many inputs ; SCEVUnknown and AddRec with phi having many inputs
; CHECK: @foo ; CHECK: @foo
define void @foo(i1 %cond) { define void @foo(i1 %cond) {
osr.type.merge79: osr.type.merge79:
br label %bci_329 br label %bci_329
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll

; RUN: opt -scalar-evolution -analyze < %s | FileCheck %s ; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
; ;
; This checks if the min and max expressions are properly recognized by ; This checks if the min and max expressions are properly recognized by
; ScalarEvolution even though they the ICmpInst and SelectInst have different ; ScalarEvolution even though they the ICmpInst and SelectInst have different
; types. ; types.
; ;
; #define max(a, b) (a > b ? a : b) ; #define max(a, b) (a > b ? a : b)
; #define min(a, b) (a < b ? a : b) ; #define min(a, b) (a < b ? a : b)
; ;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll

; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
!0 = !{i8 0, i8 127} !0 = !{i8 0, i8 127}
define void @f0(i8* %len_addr) { define void @f0(i8* %len_addr) {
; CHECK-LABEL: Classifying expressions for: @f0 ; CHECK-LABEL: Classifying expressions for: @f0
entry: entry:
%len = load i8, i8* %len_addr, !range !0 %len = load i8, i8* %len_addr, !range !0
%len_norange = load i8, i8* %len_addr %len_norange = load i8, i8* %len_addr
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define void @s_0(i32 %n, i1* %cond) { define void @s_0(i32 %n, i1* %cond) {
; CHECK-LABEL: Classifying expressions for: @s_0 ; CHECK-LABEL: Classifying expressions for: @s_0
entry: entry:
br label %loop br label %loop
▲ Show 20 Lines • Show All 181 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/non-IV-phi.ll

; RUN: opt -scalar-evolution -analyze < %s | FileCheck %s ; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
define void @test1(i8 %t, i32 %len) { define void @test1(i8 %t, i32 %len) {
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK: %sphi = phi i32 [ %ext, %entry ], [ %idx.inc.ext, %loop ] ; CHECK: %sphi = phi i32 [ %ext, %entry ], [ %idx.inc.ext, %loop ]
; CHECK-NEXT: --> (zext i8 {%t,+,1}<%loop> to i32) ; CHECK-NEXT: --> (zext i8 {%t,+,1}<%loop> to i32)
entry: entry:
%st = zext i8 %t to i16 %st = zext i8 %t to i16
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/nowrap-preinc-limits.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @f(i1* %condition) { define void @f(i1* %condition) {
; CHECK-LABEL: Classifying expressions for: @f ; CHECK-LABEL: Classifying expressions for: @f
entry: entry:
br label %loop br label %loop
loop: loop:
%idx = phi i32 [ 0, %entry ], [ %idx.inc, %loop ] %idx = phi i32 [ 0, %entry ], [ %idx.inc, %loop ]
Show All 36 Lines

llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll

; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; ScalarEvolution should be able to fold away the sign-extensions ; ScalarEvolution should be able to fold away the sign-extensions
; on this loop with a primary induction variable incremented with ; on this loop with a primary induction variable incremented with
; a nsw add of 2 (this test is derived from the nsw-offset.ll test, but uses an ; a nsw add of 2 (this test is derived from the nsw-offset.ll test, but uses an
; assume instead of a preheader conditional branch to guard the loop). ; assume instead of a preheader conditional branch to guard the loop).
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" 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"
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/nsw-offset.ll

; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; ScalarEvolution should be able to fold away the sign-extensions ; ScalarEvolution should be able to fold away the sign-extensions
; on this loop with a primary induction variable incremented with ; on this loop with a primary induction variable incremented with
; a nsw add of 2. ; a nsw add of 2.
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" 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"
define void @foo(i32 %no, double* nocapture %d, double* nocapture %q) nounwind { define void @foo(i32 %no, double* nocapture %d, double* nocapture %q) nounwind {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/nsw.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; The addrecs in this loop are analyzable only by using nsw information. ; The addrecs in this loop are analyzable only by using nsw information.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
; CHECK: Classifying expressions for: @test1 ; CHECK: Classifying expressions for: @test1
define void @test1(double* %p) nounwind { define void @test1(double* %p) nounwind {
entry: entry:
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
declare { i16, i1 } @llvm.sadd.with.overflow.i16(i16, i16) nounwind readnone declare { i16, i1 } @llvm.sadd.with.overflow.i16(i16, i16) nounwind readnone
declare { i16, i1 } @llvm.uadd.with.overflow.i16(i16, i16) nounwind readnone declare { i16, i1 } @llvm.uadd.with.overflow.i16(i16, i16) nounwind readnone
declare { i16, i1 } @llvm.ssub.with.overflow.i16(i16, i16) nounwind readnone declare { i16, i1 } @llvm.ssub.with.overflow.i16(i16, i16) nounwind readnone
declare { i16, i1 } @llvm.usub.with.overflow.i16(i16, i16) nounwind readnone declare { i16, i1 } @llvm.usub.with.overflow.i16(i16, i16) nounwind readnone
declare { i16, i1 } @llvm.smul.with.overflow.i16(i16, i16) nounwind readnone declare { i16, i1 } @llvm.smul.with.overflow.i16(i16, i16) nounwind readnone
declare { i16, i1 } @llvm.umul.with.overflow.i16(i16, i16) nounwind readnone declare { i16, i1 } @llvm.umul.with.overflow.i16(i16, i16) nounwind readnone
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/overflow-intrinsics.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f_sadd_0(i8* %a) { define void @f_sadd_0(i8* %a) {
; CHECK-LABEL: Classifying expressions for: @f_sadd_0 ; CHECK-LABEL: Classifying expressions for: @f_sadd_0
entry: entry:
br label %for.body br label %for.body
▲ Show 20 Lines • Show All 300 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/pointer-sign-bits.ll

; RUN: opt < %s -analyze -scalar-evolution ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution
; RUN: opt < %s -disable-output -scalar-evolution
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
%JavaObject = type { [0 x i32 (...)*]*, i8* } %JavaObject = type { [0 x i32 (...)*]*, i8* }
define void @JnJVM_antlr_CSharpCodeGenerator_genBitSet__Lantlr_collections_impl_BitSet_2I(%JavaObject*, %JavaObject*, i32) { define void @JnJVM_antlr_CSharpCodeGenerator_genBitSet__Lantlr_collections_impl_BitSet_2I(%JavaObject*, %JavaObject*, i32) {
start: start:
br i1 undef, label %"stack overflow", label %"no stack overflow" br i1 undef, label %"stack overflow", label %"no stack overflow"
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/pr22179.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
%struct.anon = type { i8 } %struct.anon = type { i8 }
%struct.S = type { i32 } %struct.S = type { i32 }
@a = common global %struct.anon zeroinitializer, align 1 @a = common global %struct.anon zeroinitializer, align 1
@b = common global %struct.S zeroinitializer, align 4 @b = common global %struct.S zeroinitializer, align 4
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
Show All 19 Lines

llvm/test/Analysis/ScalarEvolution/pr22641.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define i1 @main(i16 %a) { define i1 @main(i16 %a) {
; CHECK-LABEL: Classifying expressions for: @main ; CHECK-LABEL: Classifying expressions for: @main
entry: entry:
br label %body br label %body
body: body:
%dec2 = phi i16 [ %a, %entry ], [ %dec, %cond ] %dec2 = phi i16 [ %a, %entry ], [ %dec, %cond ]
Show All 16 Lines

llvm/test/Analysis/ScalarEvolution/pr24757.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; CHECK: Loop %bb1: backedge-taken count is ((2 * %a.promoted) /u 2) ; CHECK: Loop %bb1: backedge-taken count is ((2 * %a.promoted) /u 2)
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
@a = global i8 -127, align 1 @a = global i8 -127, align 1
@b = common global i32 0, align 4 @b = common global i32 0, align 4
Show All 26 Lines

llvm/test/Analysis/ScalarEvolution/pr25369.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @hoge1() { define void @hoge1() {
; CHECK-LABEL: Classifying expressions for: @hoge1 ; CHECK-LABEL: Classifying expressions for: @hoge1
bb: bb:
br i1 undef, label %bb4, label %bb2 br i1 undef, label %bb4, label %bb2
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/pr27315.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
declare i1 @use(i64) declare i1 @use(i64)
define void @f_0() { define void @f_0() {
; CHECK-LABEL: Classifying expressions for: @f_0 ; CHECK-LABEL: Classifying expressions for: @f_0
; CHECK: %iv = phi i32 [ 0, %entry ], [ %iv.inc.nowrap, %be ] ; CHECK: %iv = phi i32 [ 0, %entry ], [ %iv.inc.nowrap, %be ]
; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> ; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop>
Show All 22 Lines

llvm/test/Analysis/ScalarEvolution/pr34538.ll

; RUN: opt -scalar-evolution -loop-deletion -simplifycfg -analyze < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS-1 ; RUN: opt -scalar-evolution -loop-deletion -simplifycfg -analyze -enable-new-pm=0 < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS-1
; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS-2 ; RUN: opt "-passes=print<scalar-evolution>,loop(loop-deletion),simplifycfg" -disable-output < %s 2>&1 | FileCheck %s --check-prefix=CHECK-ANALYSIS-1
; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s --check-prefix=CHECK-ANALYSIS-2
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s --check-prefix=CHECK-ANALYSIS-2
define i32 @pr34538() local_unnamed_addr #0 { define i32 @pr34538() local_unnamed_addr #0 {
; CHECK-ANALYSIS-1: Loop %do.body: backedge-taken count is 10000 ; CHECK-ANALYSIS-1: Loop %do.body: backedge-taken count is 10000
; CHECK-ANALYSIS-1: Loop %do.body: max backedge-taken count is 10000 ; CHECK-ANALYSIS-1: Loop %do.body: max backedge-taken count is 10000
; CHECK-ANALYSIS-1: Loop %do.body: Predicated backedge-taken count is 10000 ; CHECK-ANALYSIS-1: Loop %do.body: Predicated backedge-taken count is 10000
entry: entry:
br label %do.body br label %do.body
Show All 29 Lines

llvm/test/Analysis/ScalarEvolution/pr40420.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
define void @test(i8 %tmp6) { define void @test(i8 %tmp6) {
; CHECK-LABEL: Classifying expressions for: @test ; CHECK-LABEL: Classifying expressions for: @test
bb: bb:
br label %outer_loop br label %outer_loop
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@A = weak global [1000 x i32] zeroinitializer, align 32 @A = weak global [1000 x i32] zeroinitializer, align 32
; The resulting predicate is i16 {0,+,1} <nssw>, meanining ; The resulting predicate is i16 {0,+,1} <nssw>, meanining
; that the resulting backedge expression will be valid for: ; that the resulting backedge expression will be valid for:
; (1 + (-1 smax %M)) <= MAX_INT16 ; (1 + (-1 smax %M)) <= MAX_INT16
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/range-signedness.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @x(i1* %cond) { define void @x(i1* %cond) {
; CHECK-LABEL: Classifying expressions for: @x ; CHECK-LABEL: Classifying expressions for: @x
entry: entry:
br label %loop br label %loop
loop: loop:
%idx = phi i8 [ 0, %entry ], [ %idx.inc, %loop ] %idx = phi i8 [ 0, %entry ], [ %idx.inc, %loop ]
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll

; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; copied from flags-from-poison.ll ; copied from flags-from-poison.ll
; CHECK-LABEL: @test-add-nuw ; CHECK-LABEL: @test-add-nuw
; CHECK: --> {(1 + %offset)<nuw>,+,1}<nuw><%loop> U: [1,0) S: [1,0) ; CHECK: --> {(1 + %offset)<nuw>,+,1}<nuw><%loop> U: [1,0) S: [1,0)
define void @test-add-nuw(float* %input, i32 %offset, i32 %numIterations) { define void @test-add-nuw(float* %input, i32 %offset, i32 %numIterations) {
entry: entry:
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/returned.ll

; RUN: opt < %s -S -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
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" 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"
define i8* @foo(i32 %no, i8* nocapture %d) nounwind { define i8* @foo(i32 %no, i8* nocapture %d) nounwind {
entry: entry:
%v = call i8* @func1(i8* %d) %v = call i8* @func1(i8* %d)
%w = getelementptr i8, i8* %v, i64 5 %w = getelementptr i8, i8* %v, i64 5
ret i8* %w ret i8* %w
} }
; CHECK-LABEL: Classifying expressions for: @foo ; CHECK-LABEL: Classifying expressions for: @foo
; CHECK: %w = getelementptr i8, i8* %v, i64 5 ; CHECK: %w = getelementptr i8, i8* %v, i64 5
; CHECK-NEXT: (5 + %d) ; CHECK-NEXT: (5 + %d)
declare i8* @func1(i8* returned) nounwind argmemonly declare i8* @func1(i8* returned) nounwind argmemonly

llvm/test/Analysis/ScalarEvolution/scalable-vector.ll

; RUN: opt -scalar-evolution -analyze < %s | FileCheck %s ; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
; CHECK: %1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* null, i32 3 ; CHECK: %1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* null, i32 3
; CHECK: --> (3 * sizeof(<vscale x 4 x i32>)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK: --> (3 * sizeof(<vscale x 4 x i32>)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
; CHECK: %2 = getelementptr <vscale x 1 x i64>, <vscale x 1 x i64>* %p, i32 1 ; CHECK: %2 = getelementptr <vscale x 1 x i64>, <vscale x 1 x i64>* %p, i32 1
; CHECK: --> (sizeof(<vscale x 1 x i64>) + %p) U: full-set S: full-set ; CHECK: --> (sizeof(<vscale x 1 x i64>) + %p) U: full-set S: full-set
define void @a(<vscale x 1 x i64> *%p) { define void @a(<vscale x 1 x i64> *%p) {
getelementptr <vscale x 4 x i32>, <vscale x 4 x i32> *null, i32 3 getelementptr <vscale x 4 x i32>, <vscale x 4 x i32> *null, i32 3
getelementptr <vscale x 1 x i64>, <vscale x 1 x i64> *%p, i32 1 getelementptr <vscale x 1 x i64>, <vscale x 1 x i64> *%p, i32 1
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/scev-dispositions.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @single_loop(i32* %buf, i32 %start) { define void @single_loop(i32* %buf, i32 %start) {
; CHECK-LABEL: Classifying expressions for: @single_loop ; CHECK-LABEL: Classifying expressions for: @single_loop
entry: entry:
%val = add i32 %start, 400 %val = add i32 %start, 400
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/scev-prestart-nowrap.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; An example run where SCEV(%postinc)->getStart() may overflow: ; An example run where SCEV(%postinc)->getStart() may overflow:
; ;
; %start = INT_SMAX ; %start = INT_SMAX
; %low.limit = INT_SMIN ; %low.limit = INT_SMIN
; %high.limit = < not used > ; %high.limit = < not used >
; ;
; >> entry: ; >> entry:
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/sdiv.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
; CHECK-LABEL: '_Z4loopi' ; CHECK-LABEL: '_Z4loopi'
; CHECK-NEXT: Classifying expressions for: @_Z4loopi ; CHECK-NEXT: Classifying expressions for: @_Z4loopi
; CHECK-NEXT: %storage = alloca [2 x i32], align 4 ; CHECK-NEXT: %storage = alloca [2 x i32], align 4
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/sext-inreg.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9.6" target triple = "i386-apple-darwin9.6"
define i64 @foo(i64* nocapture %x, i64 %n) nounwind { define i64 @foo(i64* nocapture %x, i64 %n) nounwind {
; CHECK-LABEL: Classifying expressions for: @foo ; CHECK-LABEL: Classifying expressions for: @foo
entry: entry:
%t0 = icmp sgt i64 %n, 0 %t0 = icmp sgt i64 %n, 0
Show All 26 Lines

llvm/test/Analysis/ScalarEvolution/sext-iv-0.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; Convert (sext {-128,+,1}) to {sext(-128),+,sext(1)}, since the ; Convert (sext {-128,+,1}) to {sext(-128),+,sext(1)}, since the
; trip count is within range where this is safe. ; trip count is within range where this is safe.
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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo(double* nocapture %x) nounwind { define void @foo(double* nocapture %x) nounwind {
Show All 29 Lines

llvm/test/Analysis/ScalarEvolution/sext-iv-1.ll

; RUN: opt < %s -scalar-evolution -analyze \ ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: | FileCheck %s ; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64) ; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64) ; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64) ; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64) ; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64) ; CHECK: --> (sext i{{.}} {{{.*}},+,{{.*}}}<%bb1> to i64)
; CHECK-NOT: --> (sext ; CHECK-NOT: --> (sext
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/sext-iv-2.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: %tmp3 = sext i8 %tmp2 to i32 ; CHECK: %tmp3 = sext i8 %tmp2 to i32
; CHECK: --> (sext i8 {0,+,1}<%bb1> to i32){{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: -1 ; CHECK: --> (sext i8 {0,+,1}<%bb1> to i32){{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: -1
; CHECK: %tmp4 = mul i32 %tmp3, %i.02 ; CHECK: %tmp4 = mul i32 %tmp3, %i.02
; CHECK: --> ((sext i8 {0,+,1}<%bb1> to i32) * {0,+,1}<%bb>){{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: {0,+,-1}<%bb> ; CHECK: --> ((sext i8 {0,+,1}<%bb1> to i32) * {0,+,1}<%bb>){{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: {0,+,-1}<%bb>
; These sexts are not foldable. ; These sexts are not foldable.
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/sext-mul.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: %tmp9 = shl i64 %tmp8, 33 ; CHECK: %tmp9 = shl i64 %tmp8, 33
; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64))) ; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
; CHECK: %tmp10 = ashr exact i64 %tmp9, 32 ; CHECK: %tmp10 = ashr exact i64 %tmp9, 32
; CHECK-NEXT: --> {{.*}} Exits: (sext i32 (-2 + (2 * %arg2)) to i64) ; CHECK-NEXT: --> {{.*}} Exits: (sext i32 (-2 + (2 * %arg2)) to i64)
; CHECK: %tmp11 = getelementptr inbounds i32, i32* %arg, i64 %tmp10 ; CHECK: %tmp11 = getelementptr inbounds i32, i32* %arg, i64 %tmp10
; CHECK-NEXT: --> {{.*}} Exits: ((4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg) ; CHECK-NEXT: --> {{.*}} Exits: ((4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg)
; CHECK: %tmp14 = or i64 %tmp10, 1 ; CHECK: %tmp14 = or i64 %tmp10, 1
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @f(i1 %c) { define void @f(i1 %c) {
; CHECK-LABEL: Classifying expressions for: @f ; CHECK-LABEL: Classifying expressions for: @f
entry: entry:
%start = select i1 %c, i32 100, i32 0 %start = select i1 %c, i32 100, i32 0
%step = select i1 %c, i32 -1, i32 1 %step = select i1 %c, i32 -1, i32 1
br label %loop br label %loop
Show All 14 Lines

llvm/test/Analysis/ScalarEvolution/sext-zero.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: %tmp9 = shl i64 %tmp8, 33 ; CHECK: %tmp9 = shl i64 %tmp8, 33
; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64))) ; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
; CHECK-NEXT: %tmp10 = ashr exact i64 %tmp9, 0 ; CHECK-NEXT: %tmp10 = ashr exact i64 %tmp9, 0
; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64))) ; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
define void @foo(i32* nocapture %arg, i32 %arg1, i32 %arg2) { define void @foo(i32* nocapture %arg, i32 %arg1, i32 %arg2) {
bb: bb:
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/shift-op.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @test0(i32 %init) { define void @test0(i32 %init) {
; CHECK-LABEL: Classifying expressions for: @test0 ; CHECK-LABEL: Classifying expressions for: @test0
; CHECK: Loop %loop: max backedge-taken count is 32 ; CHECK: Loop %loop: max backedge-taken count is 32
entry: entry:
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/shl-lshr-differentconstmask.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; The obvious case. ; The obvious case.
define i32 @mul_biggerShl(i32 %val) nounwind { define i32 @mul_biggerShl(i32 %val) nounwind {
; CHECK-LABEL: 'mul_biggerShl' ; CHECK-LABEL: 'mul_biggerShl'
; CHECK-NEXT: Classifying expressions for: @mul_biggerShl ; CHECK-NEXT: Classifying expressions for: @mul_biggerShl
; CHECK-NEXT: %tmp1 = mul i32 %val, 64 ; CHECK-NEXT: %tmp1 = mul i32 %val, 64
; CHECK-NEXT: --> (64 * %val) U: [0,-63) S: [-2147483648,2147483585) ; CHECK-NEXT: --> (64 * %val) U: [0,-63) S: [-2147483648,2147483585)
; CHECK-NEXT: %tmp2 = udiv i32 %tmp1, 16 ; CHECK-NEXT: %tmp2 = udiv i32 %tmp1, 16
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/sle.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; ScalarEvolution should be able to use nsw information to prove that ; ScalarEvolution should be able to use nsw information to prove that
; this loop has a finite trip count. ; this loop has a finite trip count.
; CHECK: @le ; CHECK: @le
; CHECK: Loop %for.body: backedge-taken count is %n ; CHECK: Loop %for.body: backedge-taken count is %n
; CHECK: Loop %for.body: max backedge-taken count is 9223372036854775807 ; CHECK: Loop %for.body: max backedge-taken count is 9223372036854775807
Show All 18 Lines

llvm/test/Analysis/ScalarEvolution/smax-br-phi-idioms.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define i32 @f0(i32 %x, i32 %y) { define i32 @f0(i32 %x, i32 %y) {
; CHECK-LABEL: Classifying expressions for: @f0 ; CHECK-LABEL: Classifying expressions for: @f0
entry: entry:
%c = icmp sgt i32 %y, 0 %c = icmp sgt i32 %y, 0
br i1 %c, label %add, label %merge br i1 %c, label %add, label %merge
add: add:
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/smax.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR1614 ; PR1614
; CHECK: --> (%a smax %b) ; CHECK: --> (%a smax %b)
; CHECK: --> (%a smax %b smax %c) ; CHECK: --> (%a smax %b smax %c)
; CHECK-NOT: smax ; CHECK-NOT: smax
define i32 @x(i32 %a, i32 %b, i32 %c) { define i32 @x(i32 %a, i32 %b, i32 %c) {
%A = icmp sgt i32 %a, %b %A = icmp sgt i32 %a, %b
%B = select i1 %A, i32 %a, i32 %b %B = select i1 %A, i32 %a, i32 %b
%C = icmp sle i32 %c, %B %C = icmp sle i32 %c, %B
%D = select i1 %C, i32 %B, i32 %c %D = select i1 %C, i32 %B, i32 %c
ret i32 %D ret i32 %D
} }

llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: Printing analysis 'Scalar Evolution Analysis' for function 'f0': ; CHECK-LABEL: Printing analysis 'Scalar Evolution Analysis' for function 'f0':
; CHECK-NEXT: Classifying expressions for: @f0 ; CHECK-NEXT: Classifying expressions for: @f0
; CHECK-NEXT: %v0 = phi i16 [ 2, %b0 ], [ %v2, %b1 ] ; CHECK-NEXT: %v0 = phi i16 [ 2, %b0 ], [ %v2, %b1 ]
; CHECK-NEXT: --> {2,+,1}<nuw><nsw><%b1> U: [2,4) S: [2,4) Exits: 3 LoopDispositions: { %b1: Computable } ; CHECK-NEXT: --> {2,+,1}<nuw><nsw><%b1> U: [2,4) S: [2,4) Exits: 3 LoopDispositions: { %b1: Computable }
; CHECK-NEXT: %v1 = phi i16 [ 1, %b0 ], [ %v3, %b1 ] ; CHECK-NEXT: %v1 = phi i16 [ 1, %b0 ], [ %v3, %b1 ]
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll

; RUN: opt -analyze -scalar-evolution -S < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
; The exit value from this loop was originally calculated as 0. ; The exit value from this loop was originally calculated as 0.
; The actual exit condition is 256*256 == 0 (in i16). ; The actual exit condition is 256*256 == 0 (in i16).
; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f0': ; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f0':
; CHECK-NEXT: Classifying expressions for: @f0 ; CHECK-NEXT: Classifying expressions for: @f0
; CHECK-NEXT: %v1 = phi i16 [ 0, %b0 ], [ %v2, %b1 ] ; CHECK-NEXT: %v1 = phi i16 [ 0, %b0 ], [ %v2, %b1 ]
; CHECK-NEXT: --> {0,+,-1}<%b1> U: [-255,1) S: [-255,1) Exits: -255 LoopDispositions: { %b1: Computable } ; CHECK-NEXT: --> {0,+,-1}<%b1> U: [-255,1) S: [-255,1) Exits: -255 LoopDispositions: { %b1: Computable }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/solve-quadratic.ll

; RUN: opt -analyze -scalar-evolution -S -debug-only=scalar-evolution,apint < %s 2>&1 | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S -debug-only=scalar-evolution,apint < %s 2>&1 | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S -debug-only=scalar-evolution,apint < %s 2>&1 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; Use the following template to get a chrec {L,+,M,+,N}. ; Use the following template to get a chrec {L,+,M,+,N}.
; ;
; define signext i32 @func() { ; define signext i32 @func() {
; entry: ; entry:
; br label %loop ; br label %loop
; ;
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/srem.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 { define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
; CHECK-LABEL: '_Z4loopi' ; CHECK-LABEL: '_Z4loopi'
; CHECK-NEXT: Classifying expressions for: @_Z4loopi ; CHECK-NEXT: Classifying expressions for: @_Z4loopi
; CHECK-NEXT: %storage = alloca [2 x i32], align 4 ; CHECK-NEXT: %storage = alloca [2 x i32], align 4
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/strip-injective-zext.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; The initial SCEV for the backedge count is ; The initial SCEV for the backedge count is
; (zext i2 {(trunc i32 (1 + %a1) to i2),+,1}<%b2> to i32). ; (zext i2 {(trunc i32 (1 + %a1) to i2),+,1}<%b2> to i32).
; In howFarToZero, this was further converted to an add-rec, the complexity ; In howFarToZero, this was further converted to an add-rec, the complexity
; of which defeated the calculation of the backedge taken count. ; of which defeated the calculation of the backedge taken count.
; Since such zero-extensions preserve the values being extended, strip ; Since such zero-extensions preserve the values being extended, strip
; them in howFarToZero to simplify the input SCEV. ; them in howFarToZero to simplify the input SCEV.
Show All 36 Lines

llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @unsimplified_and1(i32 %n) { define void @unsimplified_and1(i32 %n) {
; CHECK-LABEL: 'unsimplified_and1' ; CHECK-LABEL: 'unsimplified_and1'
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and1 ; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and1
; CHECK-NEXT: Loop %loop: backedge-taken count is %n ; CHECK-NEXT: Loop %loop: backedge-taken count is %n
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count-pow2.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
define void @test1(i32 %n) { define void @test1(i32 %n) {
entry: entry:
%s = mul i32 %n, 96 %s = mul i32 %n, 96
br label %loop br label %loop
loop: loop:
%i = phi i32 [ 0, %entry ], [ %i.next, %loop ] %i = phi i32 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i32 %i, 32 %i.next = add i32 %i, 32
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count-switch.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
declare void @foo() declare void @foo()
define void @test1() nounwind { define void @test1() nounwind {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %if.end, %entry for.cond: ; preds = %if.end, %entry
Show All 21 Lines

llvm/test/Analysis/ScalarEvolution/trip-count-unknown-stride.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; ScalarEvolution should be able to compute trip count of the loop by proving ; ScalarEvolution should be able to compute trip count of the loop by proving
; that this is not an infinite loop with side effects. ; that this is not an infinite loop with side effects.
; CHECK: Determining loop execution counts for: @foo1 ; CHECK: Determining loop execution counts for: @foo1
; CHECK: backedge-taken count is ((-1 + %n) /u %s) ; CHECK: backedge-taken count is ((-1 + %n) /u %s)
; We should have a conservative estimate for the max backedge taken count for ; We should have a conservative estimate for the max backedge taken count for
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-max-iterations=0 -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-max-iterations=0 -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = weak global [1000 x i32] zeroinitializer, align 32 @A = weak global [1000 x i32] zeroinitializer, align 32
define void @PR1101(i32 %N) { define void @PR1101(i32 %N) {
; CHECK-LABEL: 'PR1101' ; CHECK-LABEL: 'PR1101'
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count10.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
; Trip counts with trivial exit conditions. ; Trip counts with trivial exit conditions.
define void @a(i64 %n) nounwind { define void @a(i64 %n) nounwind {
; CHECK-LABEL: 'a' ; CHECK-LABEL: 'a'
; CHECK-NEXT: Determining loop execution counts for: @a ; CHECK-NEXT: Determining loop execution counts for: @a
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count.
▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count11.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-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" target datalayout = "e-p:64:64:64-p1:16:16:16-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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@foo.a = internal constant [8 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7], align 16 @foo.a = internal constant [8 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7], align 16
@foo.a_as1 = internal addrspace(1) constant [8 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7], align 16 @foo.a_as1 = internal addrspace(1) constant [8 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7], align 16
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count12.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: Determining loop execution counts for: @test ; CHECK: Determining loop execution counts for: @test
; CHECK: Loop %for.body: backedge-taken count is ((-2 + %len) /u 2) ; CHECK: Loop %for.body: backedge-taken count is ((-2 + %len) /u 2)
; CHECK: Loop %for.body: max backedge-taken count is 1073741823 ; CHECK: Loop %for.body: max backedge-taken count is 1073741823
define zeroext i16 @test(i16* nocapture %p, i32 %len) nounwind readonly { define zeroext i16 @test(i16* nocapture %p, i32 %len) nounwind readonly {
entry: entry:
%cmp2 = icmp sgt i32 %len, 1 %cmp2 = icmp sgt i32 %len, 1
Show All 26 Lines

llvm/test/Analysis/ScalarEvolution/trip-count13.ll

; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @u_0(i8 %rhs) { define void @u_0(i8 %rhs) {
; E.g.: %rhs = 255, %start = 99, backedge taken 156 times ; E.g.: %rhs = 255, %start = 99, backedge taken 156 times
entry: entry:
%start = add i8 %rhs, 100 %start = add i8 %rhs, 100
br label %loop br label %loop
loop: loop:
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count14.ll

; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @s32_max1(i32 %n, i32* %p) { define void @s32_max1(i32 %n, i32* %p) {
entry: entry:
%add = add i32 %n, 1 %add = add i32 %n, 1
br label %do.body br label %do.body
do.body: do.body:
%i.0 = phi i32 [ %n, %entry ], [ %inc, %do.body ] %i.0 = phi i32 [ %n, %entry ], [ %inc, %do.body ]
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count15.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @umin_unsigned_check(i64 %n) { define void @umin_unsigned_check(i64 %n) {
; CHECK-LABEL: 'umin_unsigned_check' ; CHECK-LABEL: 'umin_unsigned_check'
; CHECK-NEXT: Classifying expressions for: @umin_unsigned_check ; CHECK-NEXT: Classifying expressions for: @umin_unsigned_check
; CHECK-NEXT: %min.n = select i1 %min.cmp, i64 4096, i64 %n ; CHECK-NEXT: %min.n = select i1 %min.cmp, i64 4096, i64 %n
; CHECK-NEXT: --> (4096 umin %n) U: [0,4097) S: [0,4097) ; CHECK-NEXT: --> (4096 umin %n) U: [0,4097) S: [0,4097)
; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,4098) S: [0,4098) Exits: (1 + (4096 umin %n))<nuw><nsw> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,4098) S: [0,4098) Exits: (1 + (4096 umin %n))<nuw><nsw> LoopDispositions: { %loop: Computable }
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count2.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
@A = weak global [1000 x i32] zeroinitializer, align 32 @A = weak global [1000 x i32] zeroinitializer, align 32
define void @PR1101(i32 %N) { define void @PR1101(i32 %N) {
; CHECK-LABEL: 'PR1101' ; CHECK-LABEL: 'PR1101'
; CHECK-NEXT: Determining loop execution counts for: @PR1101 ; CHECK-NEXT: Determining loop execution counts for: @PR1101
; CHECK-NEXT: Loop %bb3: backedge-taken count is 4 ; CHECK-NEXT: Loop %bb3: backedge-taken count is 4
; CHECK-NEXT: Loop %bb3: max backedge-taken count is 4 ; CHECK-NEXT: Loop %bb3: max backedge-taken count is 4
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/trip-count3.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -scalar-evolution -analyze -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
; ScalarEvolution can't compute a trip count because it doesn't know if ; ScalarEvolution can't compute a trip count because it doesn't know if
; dividing by the stride will have a remainder. This could theoretically ; dividing by the stride will have a remainder. This could theoretically
; be teaching it how to use a more elaborate trip count computation. ; be teaching it how to use a more elaborate trip count computation.
%struct.FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] } %struct.FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct.FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] }
%struct.SHA_INFO = type { [5 x i32], i32, i32, [16 x i32] } %struct.SHA_INFO = type { [5 x i32], i32, i32, [16 x i32] }
%struct._IO_marker = type { %struct._IO_marker*, %struct.FILE*, i32 } %struct._IO_marker = type { %struct._IO_marker*, %struct.FILE*, i32 }
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count4.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
; ScalarEvolution should be able to compute a loop exit value for %indvar.i8. ; ScalarEvolution should be able to compute a loop exit value for %indvar.i8.
define void @another_count_down_signed(double* %d, i64 %n) nounwind { define void @another_count_down_signed(double* %d, i64 %n) nounwind {
; CHECK-LABEL: 'another_count_down_signed' ; CHECK-LABEL: 'another_count_down_signed'
; CHECK-NEXT: Determining loop execution counts for: @another_count_down_signed ; CHECK-NEXT: Determining loop execution counts for: @another_count_down_signed
; CHECK-NEXT: Loop %loop: backedge-taken count is (-11 + %n) ; CHECK-NEXT: Loop %loop: backedge-taken count is (-11 + %n)
; CHECK-NEXT: Loop %loop: max backedge-taken count is -1 ; CHECK-NEXT: Loop %loop: max backedge-taken count is -1
Show All 22 Lines

llvm/test/Analysis/ScalarEvolution/trip-count5.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; ScalarEvolution should be able to compute a maximum trip count ; ScalarEvolution should be able to compute a maximum trip count
; value sufficient to fold away both sext casts. ; value sufficient to fold away both sext casts.
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" 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"
define float @t(float* %pTmp1, float* %peakWeight, float* %nrgReducePeakrate, i32 %bim) nounwind { define float @t(float* %pTmp1, float* %peakWeight, float* %nrgReducePeakrate, i32 %bim) nounwind {
; CHECK-LABEL: Classifying expressions for: @t ; CHECK-LABEL: Classifying expressions for: @t
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count6.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
@mode_table = global [4 x i32] zeroinitializer ; <[4 x i32]*> [#uses=1] @mode_table = global [4 x i32] zeroinitializer ; <[4 x i32]*> [#uses=1]
define i8 @f() { define i8 @f() {
; CHECK-LABEL: 'f' ; CHECK-LABEL: 'f'
; CHECK-NEXT: Determining loop execution counts for: @f ; CHECK-NEXT: Determining loop execution counts for: @f
; CHECK-NEXT: Loop %bb: <multiple exits> Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %bb: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: exit count for bb: ***COULDNOTCOMPUTE*** ; CHECK-NEXT: exit count for bb: ***COULDNOTCOMPUTE***
Show All 35 Lines

llvm/test/Analysis/ScalarEvolution/trip-count7.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
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" 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"
%struct.complex = type { float, float } %struct.complex = type { float, float }
%struct.element = type { i32, i32 } %struct.element = type { i32, i32 }
%struct.node = type { %struct.node*, %struct.node*, i32 } %struct.node = type { %struct.node*, %struct.node*, i32 }
@seed = external global i64 ; <i64*> [#uses=0] @seed = external global i64 ; <i64*> [#uses=0]
@_2E_str = external constant [18 x i8], align 1 ; <[18 x i8]*> [#uses=0] @_2E_str = external constant [18 x i8], align 1 ; <[18 x i8]*> [#uses=0]
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trip-count8.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -analyze -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution -scalar-evolution-classify-expressions=0 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
; PR4599 ; PR4599
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" 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"
define i32 @foo(i32 %ecx) nounwind { define i32 @foo(i32 %ecx) nounwind {
; CHECK-LABEL: 'foo' ; CHECK-LABEL: 'foo'
; CHECK-NEXT: Determining loop execution counts for: @foo ; CHECK-NEXT: Determining loop execution counts for: @foo
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %ecx) ; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %ecx)
Show All 35 Lines

llvm/test/Analysis/ScalarEvolution/trip-count9.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -analyze -scalar-evolution -S -scalar-evolution-classify-expressions=0 < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S -scalar-evolution-classify-expressions=0 < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S -scalar-evolution-classify-expressions=0 < %s 2>&1 | FileCheck %s
; Every combination of ; Every combination of
; - starting at 0, 1, or %x ; - starting at 0, 1, or %x
; - steping by 1 or 2 ; - steping by 1 or 2
; - stopping at %n or %n*2 ; - stopping at %n or %n*2
; - using nsw, or not ; - using nsw, or not
; Some of these represent missed opportunities. ; Some of these represent missed opportunities.
▲ Show 20 Lines • Show All 518 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/tripmultiple_calculation.ll

; RUN: opt -S -analyze -scalar-evolution < %s 2>&1 | FileCheck %s ; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s 2>&1 | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 2>&1 | FileCheck %s
; umin is represented using -1 * umax in scalar evolution. -1 is considered as the ; umin is represented using -1 * umax in scalar evolution. -1 is considered as the
; constant of the multiply expression (-1 * ((-1 + (-1 * %a)) umax (-1 + (-1 * %b)))). ; constant of the multiply expression (-1 * ((-1 + (-1 * %a)) umax (-1 + (-1 * %b)))).
; Returns the greatest power of 2 divisor by evaluating the minimal trailing zeros ; Returns the greatest power of 2 divisor by evaluating the minimal trailing zeros
; for the trip count expression. ; for the trip count expression.
; ;
; int foo(uint32_t a, uint32_t b, uint32_t *c) { ; int foo(uint32_t a, uint32_t b, uint32_t *c) {
; for (uint32_t i = 0; i < (uint32_t)(a < b ? a : b) + 1; i++) ; for (uint32_t i = 0; i < (uint32_t)(a < b ? a : b) + 1; i++)
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/trunc-simplify.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; Check that we convert ; Check that we convert
; trunc(C * a) -> trunc(C) * trunc(a) ; trunc(C * a) -> trunc(C) * trunc(a)
; if C is a constant. ; if C is a constant.
; CHECK-LABEL: @trunc_of_mul ; CHECK-LABEL: @trunc_of_mul
define i8 @trunc_of_mul(i32 %a) { define i8 @trunc_of_mul(i32 %a) {
%b = mul i32 %a, 100 %b = mul i32 %a, 100
; CHECK: %c ; CHECK: %c
Show All 16 Lines

llvm/test/Analysis/ScalarEvolution/truncate.ll

; RUN: opt < %s -analyze -scalar-evolution 2>&1 | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 2>&1 | FileCheck %s
; RUN: opt < %s -passes='print<scalar-evolution>' -S 2>&1 | FileCheck %s ; RUN: opt < %s -passes='print<scalar-evolution>' -S 2>&1 | FileCheck %s
; Regression test for assert ScalarEvolution::getTruncateExpr. ; Regression test for assert ScalarEvolution::getTruncateExpr.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:1"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @snork(i8* %arg, i8 %arg1, i64 %arg2) { define void @snork(i8* %arg, i8 %arg1, i64 %arg2) {
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
define void @umin_sext_x_zext_x(i32 %len) { define void @umin_sext_x_zext_x(i32 %len) {
; CHECK-LABEL: 'umin_sext_x_zext_x' ; CHECK-LABEL: 'umin_sext_x_zext_x'
; CHECK-NEXT: Classifying expressions for: @umin_sext_x_zext_x ; CHECK-NEXT: Classifying expressions for: @umin_sext_x_zext_x
; CHECK-NEXT: %len.zext = zext i32 %len to i64 ; CHECK-NEXT: %len.zext = zext i32 %len to i64
; CHECK-NEXT: --> (zext i32 %len to i64) U: [0,4294967296) S: [0,4294967296) ; CHECK-NEXT: --> (zext i32 %len to i64) U: [0,4294967296) S: [0,4294967296)
; CHECK-NEXT: %len.sext = sext i32 %len to i64 ; CHECK-NEXT: %len.sext = sext i32 %len to i64
; CHECK-NEXT: --> (sext i32 %len to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) ; CHECK-NEXT: --> (sext i32 %len to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648)
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/undefined.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; ScalarEvolution shouldn't attempt to interpret expressions which have ; ScalarEvolution shouldn't attempt to interpret expressions which have
; undefined results. ; undefined results.
define void @foo(i64 %x) { define void @foo(i64 %x) {
%a = udiv i64 %x, 0 %a = udiv i64 %x, 0
; CHECK: --> (%x /u 0) ; CHECK: --> (%x /u 0)
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/unknown_phis.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
define void @merge_values_with_ranges(i32 *%a_len_ptr, i32 *%b_len_ptr, i1 %unknown_cond) { define void @merge_values_with_ranges(i32 *%a_len_ptr, i32 *%b_len_ptr, i1 %unknown_cond) {
; CHECK-LABEL: Classifying expressions for: @merge_values_with_ranges ; CHECK-LABEL: Classifying expressions for: @merge_values_with_ranges
; CHECK: %len = phi i32 [ %len_a, %if.true ], [ %len_b, %if.false ] ; CHECK: %len = phi i32 [ %len_a, %if.true ], [ %len_b, %if.false ]
; CHECK-NEXT: --> %len U: [0,2147483647) S: [0,2147483647) ; CHECK-NEXT: --> %len U: [0,2147483647) S: [0,2147483647)
entry: entry:
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/unreachable-code.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; CHECK: %t = add i64 %t, 1 ; CHECK: %t = add i64 %t, 1
; CHECK: --> undef ; CHECK: --> undef
define void @foo() { define void @foo() {
entry: entry:
ret void ret void
dead: dead:
%t = add i64 %t, 1 %t = add i64 %t, 1
ret void ret void
} }

llvm/test/Analysis/ScalarEvolution/unsimplified-loop.ll

; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; This loop has no preheader, multiple backedges, etc., but ScalarEvolution ; This loop has no preheader, multiple backedges, etc., but ScalarEvolution
; should still be able to analyze it. ; should still be able to analyze it.
; CHECK: %i = phi i64 [ 5, %entry ], [ 5, %alt ], [ %i.next, %loop.a ], [ %i.next, %loop.b ] ; CHECK: %i = phi i64 [ 5, %entry ], [ 5, %alt ], [ %i.next, %loop.a ], [ %i.next, %loop.b ]
; CHECK-NEXT: --> {5,+,1}<%loop> ; CHECK-NEXT: --> {5,+,1}<%loop>
define void @foo(i1 %p, i1 %q, i1 %s, i1 %u) { define void @foo(i1 %p, i1 %q, i1 %s, i1 %u) {
Show All 20 Lines

llvm/test/Analysis/ScalarEvolution/urem-0.ll

; RUN: opt < %s -scalar-evolution -analyze | FileCheck %s ; RUN: opt < %s -scalar-evolution -analyze -enable-new-pm=0 | FileCheck %s
; RUN: opt < %s "-passes=print<scalar-evolution>" -disable-output 2>&1 | FileCheck %s
define i8 @foo(i8 %a) { define i8 @foo(i8 %a) {
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
%t0 = urem i8 %a, 27 %t0 = urem i8 %a, 27
; CHECK: %t0 = urem i8 %a, 27 ; CHECK: %t0 = urem i8 %a, 27
; CHECK-NEXT: --> ((-27 * (%a /u 27)) + %a) ; CHECK-NEXT: --> ((-27 * (%a /u 27)) + %a)
ret i8 %t0 ret i8 %t0
} }
Show All 24 Lines

llvm/test/Analysis/ScalarEvolution/widenable-condition.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -analyze -scalar-evolution < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
; The semanics of this example are a bit subtle. The loop is required ; The semanics of this example are a bit subtle. The loop is required
; execute some number of times up to 1999. The compiler is free to reduce ; execute some number of times up to 1999. The compiler is free to reduce
; the number of said iterations to zero (or any value in between) if desired, ; the number of said iterations to zero (or any value in between) if desired,
; but if it does so, the return value and the last value stored to G must ; but if it does so, the return value and the last value stored to G must
; agree. For SCEV, this translates as widenable conditions preventing exact ; agree. For SCEV, this translates as widenable conditions preventing exact
; exit counts from being computed, but not restricting max exit counts. ; exit counts from being computed, but not restricting max exit counts.
; It's tempting to say that SCEV should return a precise exit count here, but ; It's tempting to say that SCEV should return a precise exit count here, but
Show All 35 Lines

llvm/test/Analysis/ScalarEvolution/zext-divrem.ll

; RUN: opt -analyze -scalar-evolution -S < %s | FileCheck %s ; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution -S < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
define i64 @test1(i32 %a, i32 %b) { define i64 @test1(i32 %a, i32 %b) {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
%div = udiv i32 %a, %b %div = udiv i32 %a, %b
%zext = zext i32 %div to i64 %zext = zext i32 %div to i64
; CHECK: %zext ; CHECK: %zext
; CHECK-NEXT: --> ((zext i32 %a to i64) /u (zext i32 %b to i64)) ; CHECK-NEXT: --> ((zext i32 %a to i64) /u (zext i32 %b to i64))
ret i64 %zext ret i64 %zext
Show All 33 Lines

llvm/test/Analysis/ScalarEvolution/zext-mul.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; Check that we convert ; Check that we convert
; zext((a * b)<nuw>) ; zext((a * b)<nuw>)
; to ; to
; (zext(a) * zext(b))<nuw> ; (zext(a) * zext(b))<nuw>
declare i32 @get_int(); declare i32 @get_int();
Show All 29 Lines

llvm/test/Analysis/ScalarEvolution/zext-wrap.ll

; RUN: opt < %s -analyze -scalar-evolution | FileCheck %s ; RUN: opt < %s -analyze -enable-new-pm=0 -scalar-evolution | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; PR4569 ; PR4569
define i16 @main() nounwind { define i16 @main() nounwind {
entry: entry:
br label %bb.i br label %bb.i
bb.i: ; preds = %bb1.i, %bb.nph bb.i: ; preds = %bb1.i, %bb.nph
; We should be able to find the range for this expression. ; We should be able to find the range for this expression.
Show All 18 Lines