6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 04:33:05 +00:00
Code Issues Projects Releases Wiki Activity

Use WriteAsOperand instead of getName() to print loop header names,

Browse Source 
so that unnamed blocks are handled.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@93059 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2010-01-09 18:17:45 +00:00
parent 7a523dde57
commit 3073329c53
22 changed files with 48 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Analysis/IVUsers.cpp
View File

@ -128,8 +128,9 @@ static bool getSCEVStartAndStride(const SCEV *&SH, Loop *L, Loop *UseLoop,
if (!AddRecStride->properlyDominates(Header, DT))
return false;
DEBUG(dbgs() << "[" << L->getHeader()->getName()
<< "] Variable stride: " << *AddRec << "\n");
DEBUG(dbgs() << "[";
WriteAsOperand(dbgs(), L->getHeader(), /*PrintType=*/false);
dbgs() << "] Variable stride: " << *AddRec << "\n");
}
Stride = AddRecStride;

22
lib/Analysis/ScalarEvolution.cpp
View File

@ -316,7 +316,9 @@ void SCEVAddRecExpr::print(raw_ostream &OS) const {
OS << "{" << *Operands[0];
for (unsigned i = 1, e = Operands.size(); i != e; ++i)
OS << ",+," << *Operands[i];
OS << "}<" << L->getHeader()->getName() + ">";
OS << "}<";
WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
OS << ">";
}
void SCEVFieldOffsetExpr::print(raw_ostream &OS) const {
@ -5193,7 +5195,9 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
PrintLoopInfo(OS, SE, *I);
OS << "Loop " << L->getHeader()->getName() << ": ";
OS << "Loop ";
WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
OS << ": ";
SmallVector<BasicBlock *, 8> ExitBlocks;
L->getExitBlocks(ExitBlocks);
@ -5206,8 +5210,10 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
OS << "Unpredictable backedge-taken count. ";
}
OS << "\n";
OS << "Loop " << L->getHeader()->getName() << ": ";
OS << "\n"
"Loop ";
WriteAsOperand(OS, L->getHeader(), /*PrintType=*/false);
OS << ": ";
if (!isa<SCEVCouldNotCompute>(SE->getMaxBackedgeTakenCount(L))) {
OS << "max backedge-taken count is " << *SE->getMaxBackedgeTakenCount(L);
@ -5227,7 +5233,9 @@ void ScalarEvolution::print(raw_ostream &OS, const Module *) const {
// const isn't dangerous.
ScalarEvolution &SE = *const_cast<ScalarEvolution *>(this);
OS << "Classifying expressions for: " << F->getName() << "\n";
OS << "Classifying expressions for: ";
WriteAsOperand(OS, F, /*PrintType=*/false);
OS << "\n";
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
if (isSCEVable(I->getType())) {
OS << *I << '\n';
@ -5256,7 +5264,9 @@ void ScalarEvolution::print(raw_ostream &OS, const Module *) const {
OS << "\n";
}
OS << "Determining loop execution counts for: " << F->getName() << "\n";
OS << "Determining loop execution counts for: ";
WriteAsOperand(OS, F, /*PrintType=*/false);
OS << "\n";
for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
PrintLoopInfo(OS, &SE, *I);
}

2
test/Analysis/ScalarEvolution/2007-07-15-NegativeStride.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep {Loop bb: backedge-taken count is 100}
; RUN: -scalar-evolution-max-iterations=0 | grep {Loop %bb: backedge-taken count is 100}
; PR1533
@array = weak global [101 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=1]

2
test/Analysis/ScalarEvolution/2007-08-06-Unsigned.ll
View File

@ -1,4 +1,4 @@
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop bb: backedge-taken count is (-1 + (-1 \\* %x) + %y)}
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop %bb: backedge-taken count is (-1 + (-1 \\* %x) + %y)}
; PR1597
define i32 @f(i32 %x, i32 %y) {

2
test/Analysis/ScalarEvolution/2008-02-11-ReversedCondition.ll
View File

@ -1,4 +1,4 @@
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop header: backedge-taken count is (0 smax %n)}
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop %header: backedge-taken count is (0 smax %n)}
define void @foo(i32 %n) {
entry:

2
test/Analysis/ScalarEvolution/2008-02-12-SMAXTripCount.ll
View File

@ -1,4 +1,4 @@
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop loop: backedge-taken count is (100 + (-100 smax %n))}
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop %loop: backedge-taken count is (100 + (-100 smax %n))}
; PR2002
define void @foo(i8 %n) {

2
test/Analysis/ScalarEvolution/2008-11-18-LessThanOrEqual.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output |& \
; RUN: grep {Loop bb: backedge-taken count is (7 + (-1 \\* %argc))}
; RUN: grep {Loop %bb: backedge-taken count is (7 + (-1 \\* %argc))}
; XFAIL: *
define i32 @main(i32 %argc, i8** %argv) nounwind {

2
test/Analysis/ScalarEvolution/2008-11-18-Stride1.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {Loop bb: Unpredictable backedge-taken count\\.}
; RUN: | grep {Loop %bb: Unpredictable backedge-taken count\\.}
; ScalarEvolution can't compute a trip count because it doesn't know if
; dividing by the stride will have a remainder. This could theoretically

2
test/Analysis/ScalarEvolution/avoid-smax-0.ll
View File

@ -1,4 +1,4 @@
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop bb3: backedge-taken count is (-1 + %n)}
; RUN: opt < %s -scalar-evolution -analyze -disable-output | grep {Loop %bb3: backedge-taken count is (-1 + %n)}
; We don't want to use a max in the trip count expression in
; this testcase.

2
test/Analysis/ScalarEvolution/max-trip-count.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {\{%d,+,\[^\{\}\]\*\}<bb>}
; RUN: | grep {\{%d,+,\[^\{\}\]\*\}<%bb>}
; ScalarEvolution should be able to understand the loop and eliminate the casts.

16
test/Analysis/ScalarEvolution/nsw-offset.ll
View File

@ -18,11 +18,11 @@ bb: ; preds = %bb.nph, %bb1
%i.01 = phi i32 [ %16, %bb1 ], [ 0, %bb.nph ] ; <i32> [#uses=5]
; CHECK: %1 = sext i32 %i.01 to i64
; CHECK: --> {0,+,2}<bb>
; CHECK: --> {0,+,2}<%bb>
%1 = sext i32 %i.01 to i64 ; <i64> [#uses=1]
; CHECK: %2 = getelementptr inbounds double* %d, i64 %1
; CHECK: --> {%d,+,16}<bb>
; CHECK: --> {%d,+,16}<%bb>
%2 = getelementptr inbounds double* %d, i64 %1 ; <double*> [#uses=1]
%3 = load double* %2, align 8 ; <double> [#uses=1]
@ -32,11 +32,11 @@ bb: ; preds = %bb.nph, %bb1
%7 = or i32 %i.01, 1 ; <i32> [#uses=1]
; CHECK: %8 = sext i32 %7 to i64
; CHECK: --> {1,+,2}<bb>
; CHECK: --> {1,+,2}<%bb>
%8 = sext i32 %7 to i64 ; <i64> [#uses=1]
; CHECK: %9 = getelementptr inbounds double* %q, i64 %8
; CHECK: {(8 + %q),+,16}<bb>
; CHECK: {(8 + %q),+,16}<%bb>
%9 = getelementptr inbounds double* %q, i64 %8 ; <double*> [#uses=1]
; Artificially repeat the above three instructions, this time using
@ -44,11 +44,11 @@ bb: ; preds = %bb.nph, %bb1
%t7 = add nsw i32 %i.01, 1 ; <i32> [#uses=1]
; CHECK: %t8 = sext i32 %t7 to i64
; CHECK: --> {1,+,2}<bb>
; CHECK: --> {1,+,2}<%bb>
%t8 = sext i32 %t7 to i64 ; <i64> [#uses=1]
; CHECK: %t9 = getelementptr inbounds double* %q, i64 %t8
; CHECK: {(8 + %q),+,16}<bb>
; CHECK: {(8 + %q),+,16}<%bb>
%t9 = getelementptr inbounds double* %q, i64 %t8 ; <double*> [#uses=1]
%10 = load double* %9, align 8 ; <double> [#uses=1]
@ -72,5 +72,5 @@ return: ; preds = %bb1.return_crit_edg
ret void
}
; CHECK: Loop bb: backedge-taken count is ((-1 + %n) /u 2)
; CHECK: Loop bb: max backedge-taken count is 1073741823
; CHECK: Loop %bb: backedge-taken count is ((-1 + %n) /u 2)
; CHECK: Loop %bb: max backedge-taken count is 1073741823

2
test/Analysis/ScalarEvolution/nsw.ll
View File

@ -1,4 +1,4 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep { --> {.*,+,.*}<bb>} | count 8
; RUN: opt < %s -analyze -scalar-evolution -disable-output | grep { --> {.*,+,.*}<%bb>} | count 8
; The addrecs in this loop are analyzable only by using nsw information.

4
test/Analysis/ScalarEvolution/sext-inreg.ll
View File

@ -1,6 +1,6 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output > %t
; RUN: grep {sext i57 \{0,+,199\}<bb> to i64} %t | count 1
; RUN: grep {sext i59 \{0,+,199\}<bb> to i64} %t | count 1
; RUN: grep {sext i57 \{0,+,199\}<%bb> to i64} %t | count 1
; RUN: grep {sext i59 \{0,+,199\}<%bb> to i64} %t | count 1
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"

2
test/Analysis/ScalarEvolution/sext-iv-0.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -disable-output -scalar-evolution -analyze \
; RUN: | grep { --> \{-128,+,1\}<bb1> Exits: 127} | count 5
; RUN: | grep { --> \{-128,+,1\}<%bb1> Exits: 127} | count 5
; Convert (sext {-128,+,1}) to {sext(-128),+,sext(1)}, since the
; trip count is within range where this is safe.

2
test/Analysis/ScalarEvolution/sext-iv-1.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -disable-output -scalar-evolution -analyze \
; RUN: | grep { --> (sext i. \{.\*,+,.\*\}<bb1> to i64)} | count 5
; RUN: | grep { --> (sext i. \{.\*,+,.\*\}<%bb1> to i64)} | count 5
; Don't convert (sext {...,+,...}) to {sext(...),+,sext(...)} in cases
; where the trip count is not within range.

4
test/Analysis/ScalarEvolution/sext-iv-2.ll
View File

@ -1,9 +1,9 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output | FileCheck %s
; CHECK: %tmp3 = sext i8 %tmp2 to i32
; CHECK: --> (sext i8 {0,+,1}<bb1> to i32) Exits: -1
; CHECK: --> (sext i8 {0,+,1}<%bb1> to i32) Exits: -1
; CHECK: %tmp4 = mul i32 %tmp3, %i.02
; CHECK: --> ((sext i8 {0,+,1}<bb1> to i32) * {0,+,1}<bb>) Exits: {0,+,-1}<bb>
; CHECK: --> ((sext i8 {0,+,1}<%bb1> to i32) * {0,+,1}<%bb>) Exits: {0,+,-1}<%bb>
; These sexts are not foldable.

2
test/Analysis/ScalarEvolution/trip-count3.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -scalar-evolution -analyze -disable-output \
; RUN: | grep {Loop bb3\\.i: Unpredictable backedge-taken count\\.}
; RUN: | grep {Loop %bb3\\.i: Unpredictable backedge-taken count\\.}
; ScalarEvolution can't compute a trip count because it doesn't know if
; dividing by the stride will have a remainder. This could theoretically

2
test/Analysis/ScalarEvolution/trip-count7.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {Loop bb7.i: Unpredictable backedge-taken count\\.}
; RUN: | grep {Loop %bb7.i: Unpredictable backedge-taken count\\.}
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"

2
test/Analysis/ScalarEvolution/trip-count8.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -analyze -scalar-evolution -disable-output \
; RUN: | grep {Loop for\\.body: backedge-taken count is (-1 + \[%\]ecx)}
; RUN: | grep {Loop %for\\.body: backedge-taken count is (-1 + \[%\]ecx)}
; 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"

2
test/Analysis/ScalarEvolution/zext-wrap.ll
View File

@ -11,7 +11,7 @@ bb.i: ; preds = %bb1.i, %bb.nph
; This cast shouldn't be folded into the addrec.
; CHECK: %tmp = zext i8 %l_95.0.i1 to i16
; CHECK: --> (zext i8 {0,+,-1}<bb.i> to i16) Exits: 2
; CHECK: --> (zext i8 {0,+,-1}<%bb.i> to i16) Exits: 2
%tmp = zext i8 %l_95.0.i1 to i16

2
test/Transforms/IndVarSimplify/shrunk-constant.ll
View File

@ -1,5 +1,5 @@
; RUN: opt < %s -scalar-evolution -analyze -disable-output \
; RUN: | grep {\\--> (zext i4 {-7,+,-8}<loop> to i32)}
; RUN: | grep {\\--> (zext i4 {-7,+,-8}<%loop> to i32)}
define fastcc void @foo() nounwind {
entry:

2
test/Transforms/LoopStrengthReduce/quadradic-exit-value.ll
View File

@ -1,4 +1,4 @@
; RUN: opt < %s -analyze -iv-users -disable-output | grep {Stride i64 {3,+,2}<loop>:}
; RUN: opt < %s -analyze -iv-users -disable-output | grep {Stride i64 {3,+,2}<%loop>:}
; The value of %r is dependent on a polynomial iteration expression.