6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-23 01:24:30 +00:00
Code Issues Projects Releases Wiki Activity

Fix WriteAsOperand to not emit a leading space character. Adjust

Browse Source 
its callers to emit a space character before calling it when a
space is needed.

This fixes several spurious whitespace issues in
ScalarEvolution's debug dumps. See the test changes for
examples.

This also fixes odd space-after-tab indentation in the output
for switch statements, and changes calls from being printed like
this:
  call void @foo( i32 %x )
to this:
  call void @foo(i32 %x)


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56196 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman
2008-09-14 17:21:12 +00:00
parent e009180f2b
commit 8dae138d06
12 changed files with 70 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
lib/Analysis/ScalarEvolution.cpp
View File

@ -891,7 +891,7 @@ SCEVHandle ScalarEvolution::getAddExpr(std::vector<SCEVHandle> &Ops) {
// If we found some loop invariants, fold them into the recurrence. // If we found some loop invariants, fold them into the recurrence.
if (!LIOps.empty()) { if (!LIOps.empty()) {
// NLI + LI + { Start,+,Step} --> NLI + { LI+Start,+,Step } // NLI + LI + {Start,+,Step} --> NLI + {LI+Start,+,Step}
LIOps.push_back(AddRec->getStart()); LIOps.push_back(AddRec->getStart());
std::vector<SCEVHandle> AddRecOps(AddRec->op_begin(), AddRec->op_end()); std::vector<SCEVHandle> AddRecOps(AddRec->op_begin(), AddRec->op_end());
@ -1039,7 +1039,7 @@ SCEVHandle ScalarEvolution::getMulExpr(std::vector<SCEVHandle> &Ops) {
// If we found some loop invariants, fold them into the recurrence. // If we found some loop invariants, fold them into the recurrence.
if (!LIOps.empty()) { if (!LIOps.empty()) {
// NLI * LI * { Start,+,Step} --> NLI * { LI*Start,+,LI*Step } // NLI * LI * {Start,+,Step} --> NLI * {LI*Start,+,LI*Step}
std::vector<SCEVHandle> NewOps; std::vector<SCEVHandle> NewOps;
NewOps.reserve(AddRec->getNumOperands()); NewOps.reserve(AddRec->getNumOperands());
if (LIOps.size() == 1) { if (LIOps.size() == 1) {
@ -1155,7 +1155,7 @@ SCEVHandle ScalarEvolution::getAddRecExpr(std::vector<SCEVHandle> &Operands,
if (Operands.back()->isZero()) { if (Operands.back()->isZero()) {
Operands.pop_back(); Operands.pop_back();
return getAddRecExpr(Operands, L); // { X,+,0 } --> X return getAddRecExpr(Operands, L); // {X,+,0} --> X
} }
// Canonicalize nested AddRecs in by nesting them in order of loop depth. // Canonicalize nested AddRecs in by nesting them in order of loop depth.
@ -3044,7 +3044,7 @@ void ScalarEvolution::print(std::ostream &OS, const Module* ) const {
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
if (I->getType()->isInteger()) { if (I->getType()->isInteger()) {
OS << *I; OS << *I;
OS << " --> "; OS << " --> ";
SCEVHandle SV = getSCEV(&*I); SCEVHandle SV = getSCEV(&*I);
SV->print(OS); SV->print(OS);
OS << "\t\t"; OS << "\t\t";

86
lib/VMCore/AsmWriter.cpp
View File

@ -777,15 +777,18 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
if (CA->getNumOperands()) { if (CA->getNumOperands()) {
Out << ' '; Out << ' ';
printTypeInt(Out, ETy, TypeTable); printTypeInt(Out, ETy, TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CA->getOperand(0), WriteAsOperandInternal(Out, CA->getOperand(0),
TypeTable, Machine); TypeTable, Machine);
for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
Out << ", "; Out << ", ";
printTypeInt(Out, ETy, TypeTable); printTypeInt(Out, ETy, TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine); WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine);
} }
Out << ' ';
} }
Out << " ]"; Out << ']';
} }
return; return;
} }
@ -798,18 +801,21 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
if (N) { if (N) {
Out << ' '; Out << ' ';
printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable); printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine); WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine);
for (unsigned i = 1; i < N; i++) { for (unsigned i = 1; i < N; i++) {
Out << ", "; Out << ", ";
printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable); printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine); WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine);
} }
Out << ' ';
} }
Out << " }"; Out << '}';
if (CS->getType()->isPacked()) if (CS->getType()->isPacked())
Out << '>'; Out << '>';
return; return;
@ -821,10 +827,12 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
"Number of operands for a PackedConst must be > 0"); "Number of operands for a PackedConst must be > 0");
Out << "< "; Out << "< ";
printTypeInt(Out, ETy, TypeTable); printTypeInt(Out, ETy, TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine); WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine);
for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) { for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
Out << ", "; Out << ", ";
printTypeInt(Out, ETy, TypeTable); printTypeInt(Out, ETy, TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine); WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine);
} }
Out << " >"; Out << " >";
@ -849,6 +857,7 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) { for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
printTypeInt(Out, (*OI)->getType(), TypeTable); printTypeInt(Out, (*OI)->getType(), TypeTable);
Out << ' ';
WriteAsOperandInternal(Out, *OI, TypeTable, Machine); WriteAsOperandInternal(Out, *OI, TypeTable, Machine);
if (OI+1 != CE->op_end()) if (OI+1 != CE->op_end())
Out << ", "; Out << ", ";
@ -880,7 +889,6 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
std::map<const Type*, std::string> &TypeTable, std::map<const Type*, std::string> &TypeTable,
SlotTracker *Machine) { SlotTracker *Machine) {
Out << ' ';
if (V->hasName()) { if (V->hasName()) {
PrintLLVMName(Out, V); PrintLLVMName(Out, V);
return; return;
@ -952,8 +960,10 @@ void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, bool PrintType,
if (Context) if (Context)
fillTypeNameTable(Context, TypeNames); fillTypeNameTable(Context, TypeNames);
if (PrintType) if (PrintType) {
printTypeInt(Out, V->getType(), TypeNames); printTypeInt(Out, V->getType(), TypeNames);
Out << ' ';
}
WriteAsOperandInternal(Out, V, TypeNames, 0); WriteAsOperandInternal(Out, V, TypeNames, 0);
} }
@ -1108,8 +1118,8 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
Out << "<null operand!>"; Out << "<null operand!>";
} else { } else {
if (PrintType) { if (PrintType) {
Out << ' ';
printType(Operand->getType()); printType(Operand->getType());
Out << ' ';
} }
WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); WriteAsOperandInternal(Out, Operand, TypeNames, &Machine);
} }
@ -1120,12 +1130,12 @@ void AssemblyWriter::writeParamOperand(const Value *Operand,
if (Operand == 0) { if (Operand == 0) {
Out << "<null operand!>"; Out << "<null operand!>";
} else { } else {
Out << ' ';
// Print the type // Print the type
printType(Operand->getType()); printType(Operand->getType());
// Print parameter attributes list // Print parameter attributes list
if (Attrs != ParamAttr::None) if (Attrs != ParamAttr::None)
Out << ' ' << ParamAttr::getAsString(Attrs); Out << ' ' << ParamAttr::getAsString(Attrs);
Out << ' ';
// Print the operand // Print the operand
WriteAsOperandInternal(Out, Operand, TypeNames, &Machine); WriteAsOperandInternal(Out, Operand, TypeNames, &Machine);
} }
@ -1239,8 +1249,10 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
Out << (GV->isConstant() ? "constant " : "global "); Out << (GV->isConstant() ? "constant " : "global ");
printType(GV->getType()->getElementType()); printType(GV->getType()->getElementType());
if (GV->hasInitializer()) if (GV->hasInitializer()) {
Out << ' ';
writeOperand(GV->getInitializer(), false); writeOperand(GV->getInitializer(), false);
}
if (unsigned AddressSpace = GV->getType()->getAddressSpace()) if (unsigned AddressSpace = GV->getType()->getAddressSpace())
Out << " addrspace(" << AddressSpace << ") "; Out << " addrspace(" << AddressSpace << ") ";
@ -1474,10 +1486,10 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
if (PI == PE) { if (PI == PE) {
Out << " No predecessors!"; Out << " No predecessors!";
} else { } else {
Out << " preds ="; Out << " preds = ";
writeOperand(*PI, false); writeOperand(*PI, false);
for (++PI; PI != PE; ++PI) { for (++PI; PI != PE; ++PI) {
Out << ','; Out << ", ";
writeOperand(*PI, false); writeOperand(*PI, false);
} }
} }
@ -1559,23 +1571,25 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
// Special case conditional branches to swizzle the condition out to the front // Special case conditional branches to swizzle the condition out to the front
if (isa<BranchInst>(I) && I.getNumOperands() > 1) { if (isa<BranchInst>(I) && I.getNumOperands() > 1) {
Out << ' ';
writeOperand(I.getOperand(2), true); writeOperand(I.getOperand(2), true);
Out << ','; Out << ", ";
writeOperand(Operand, true); writeOperand(Operand, true);
Out << ','; Out << ", ";
writeOperand(I.getOperand(1), true); writeOperand(I.getOperand(1), true);
} else if (isa<SwitchInst>(I)) { } else if (isa<SwitchInst>(I)) {
// Special case switch statement to get formatting nice and correct... // Special case switch statement to get formatting nice and correct...
Out << ' ';
writeOperand(Operand , true); writeOperand(Operand , true);
Out << ','; Out << ", ";
writeOperand(I.getOperand(1), true); writeOperand(I.getOperand(1), true);
Out << " ["; Out << " [";
for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) { for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) {
Out << "\n\t\t"; Out << "\n\t\t";
writeOperand(I.getOperand(op ), true); writeOperand(I.getOperand(op ), true);
Out << ','; Out << ", ";
writeOperand(I.getOperand(op+1), true); writeOperand(I.getOperand(op+1), true);
} }
Out << "\n\t]"; Out << "\n\t]";
@ -1586,16 +1600,18 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) { for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
if (op) Out << ", "; if (op) Out << ", ";
Out << '['; Out << "[ ";
writeOperand(I.getOperand(op ), false); Out << ','; writeOperand(I.getOperand(op ), false); Out << ", ";
writeOperand(I.getOperand(op+1), false); Out << " ]"; writeOperand(I.getOperand(op+1), false); Out << " ]";
} }
} else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) { } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
Out << ' ';
writeOperand(I.getOperand(0), true); writeOperand(I.getOperand(0), true);
for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i) for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
Out << ", " << *i; Out << ", " << *i;
} else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) { } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
writeOperand(I.getOperand(0), true); Out << ','; Out << ' ';
writeOperand(I.getOperand(0), true); Out << ", ";
writeOperand(I.getOperand(1), true); writeOperand(I.getOperand(1), true);
for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i) for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
Out << ", " << *i; Out << ", " << *i;
@ -1622,10 +1638,12 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
// only do this if the first argument is a pointer to a nonvararg function, // only do this if the first argument is a pointer to a nonvararg function,
// and if the return type is not a pointer to a function. // and if the return type is not a pointer to a function.
// //
Out << ' ';
if (!FTy->isVarArg() && if (!FTy->isVarArg() &&
(!isa<PointerType>(RetTy) || (!isa<PointerType>(RetTy) ||
!isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) { !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
Out << ' '; printType(RetTy); printType(RetTy);
Out << ' ';
writeOperand(Operand, false); writeOperand(Operand, false);
} else { } else {
writeOperand(Operand, true); writeOperand(Operand, true);
@ -1633,10 +1651,10 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
Out << '('; Out << '(';
for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) { for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) {
if (op > 1) if (op > 1)
Out << ','; Out << ", ";
writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op)); writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op));
} }
Out << " )"; Out << ')';
if (PAL.getParamAttrs(0) != ParamAttr::None) if (PAL.getParamAttrs(0) != ParamAttr::None)
Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0)); Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0));
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) { } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
@ -1650,9 +1668,9 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
case CallingConv::C: break; // default case CallingConv::C: break; // default
case CallingConv::Fast: Out << " fastcc"; break; case CallingConv::Fast: Out << " fastcc"; break;
case CallingConv::Cold: Out << " coldcc"; break; case CallingConv::Cold: Out << " coldcc"; break;
case CallingConv::X86_StdCall: Out << "x86_stdcallcc "; break; case CallingConv::X86_StdCall: Out << " x86_stdcallcc"; break;
case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break; case CallingConv::X86_FastCall: Out << " x86_fastcallcc"; break;
case CallingConv::X86_SSECall: Out << "x86_ssecallcc "; break; case CallingConv::X86_SSECall: Out << " x86_ssecallcc"; break;
default: Out << " cc" << II->getCallingConv(); break; default: Out << " cc" << II->getCallingConv(); break;
} }
@ -1666,40 +1684,47 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
Out << ' '; printType(RetTy); Out << ' '; printType(RetTy);
writeOperand(Operand, false); writeOperand(Operand, false);
} else { } else {
Out << ' ';
writeOperand(Operand, true); writeOperand(Operand, true);
} }
Out << '('; Out << '(';
for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) { for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
if (op > 3) if (op > 3)
Out << ','; Out << ", ";
writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op-2)); writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op-2));
} }
Out << " )"; Out << ')';
if (PAL.getParamAttrs(0) != ParamAttr::None) if (PAL.getParamAttrs(0) != ParamAttr::None)
Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0)); Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0));
Out << "\n\t\t\tto"; Out << "\n\t\t\tto ";
writeOperand(II->getNormalDest(), true); writeOperand(II->getNormalDest(), true);
Out << " unwind"; Out << " unwind ";
writeOperand(II->getUnwindDest(), true); writeOperand(II->getUnwindDest(), true);
} else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) { } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
Out << ' '; Out << ' ';
printType(AI->getType()->getElementType()); printType(AI->getType()->getElementType());
if (AI->isArrayAllocation()) { if (AI->isArrayAllocation()) {
Out << ','; Out << ", ";
writeOperand(AI->getArraySize(), true); writeOperand(AI->getArraySize(), true);
} }
if (AI->getAlignment()) { if (AI->getAlignment()) {
Out << ", align " << AI->getAlignment(); Out << ", align " << AI->getAlignment();
} }
} else if (isa<CastInst>(I)) { } else if (isa<CastInst>(I)) {
if (Operand) writeOperand(Operand, true); // Work with broken code if (Operand) {
Out << ' ';
writeOperand(Operand, true); // Work with broken code
}
Out << " to "; Out << " to ";
printType(I.getType()); printType(I.getType());
} else if (isa<VAArgInst>(I)) { } else if (isa<VAArgInst>(I)) {
if (Operand) writeOperand(Operand, true); // Work with broken code if (Operand) {
Out << ' ';
writeOperand(Operand, true); // Work with broken code
}
Out << ", "; Out << ", ";
printType(I.getType()); printType(I.getType());
} else if (Operand) { // Print the normal way... } else if (Operand) { // Print the normal way...
@ -1729,8 +1754,9 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
printType(TheType); printType(TheType);
} }
Out << ' ';
for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) { for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
if (i) Out << ','; if (i) Out << ", ";
writeOperand(I.getOperand(i), PrintAllTypes); writeOperand(I.getOperand(i), PrintAllTypes);
} }
} }

2
test/Analysis/LoopInfo/2003-05-15-NestingProblem.ll
View File

@ -2,7 +2,7 @@
; not a child of the loopentry.6 loop. ; not a child of the loopentry.6 loop.
; ;
; RUN: llvm-as < %s | opt -analyze -loops | \ ; RUN: llvm-as < %s | opt -analyze -loops | \
; RUN: grep {^ Loop Containing: %loopentry.7} ; RUN: grep {^ Loop Containing: %loopentry.7}
define void @getAndMoveToFrontDecode() { define void @getAndMoveToFrontDecode() {
br label %endif.2 br label %endif.2

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

@ -1,5 +1,5 @@
; RUN: llvm-as < %s | opt -analyze -scalar-evolution \ ; RUN: llvm-as < %s | opt -analyze -scalar-evolution \
; RUN: -scalar-evolution-max-iterations=0 | grep {Loop bb: 100 iterations} ; RUN: -scalar-evolution-max-iterations=0 | grep {Loop bb: 100 iterations}
; 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]

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

@ -1,4 +1,4 @@
; RUN: llvm-as < %s | opt -scalar-evolution -analyze | grep {Loop bb: ( -1 + ( -1 \\* %x) + %y) iterations!} ; RUN: llvm-as < %s | opt -scalar-evolution -analyze | grep {Loop bb: (-1 + (-1 \\* %x) + %y) iterations!}
; PR1597 ; PR1597
define i32 @f(i32 %x, i32 %y) { define i32 @f(i32 %x, i32 %y) {

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

@ -1,4 +1,4 @@
; RUN: llvm-as < %s | opt -scalar-evolution -analyze | grep {Loop loop: ( 100 + ( -100 smax %n)) iterations!} ; RUN: llvm-as < %s | opt -scalar-evolution -analyze | grep {Loop loop: (100 + (-100 smax %n)) iterations!}
; PR2002 ; PR2002
define void @foo(i8 %n) { define void @foo(i8 %n) {

2
test/Analysis/ScalarEvolution/2008-07-29-SGTTripCount.ll
View File

@ -1,6 +1,6 @@
; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \ ; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | \ ; RUN: -scalar-evolution-max-iterations=0 | \
; RUN: grep -F "( -1 + ( -1 * %j)) iterations" ; RUN: grep -F "(-1 + (-1 * %j)) iterations"
; PR2607 ; PR2607
define i32 @_Z1aj(i32 %j) nounwind { define i32 @_Z1aj(i32 %j) nounwind {

2
test/Analysis/ScalarEvolution/2008-07-29-SMinExpr.ll
View File

@ -1,6 +1,6 @@
; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \ ; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | \ ; RUN: -scalar-evolution-max-iterations=0 | \
; RUN: grep -F "( -2147483632 + ( 2147483632 smax ( -1 + ( -1 * %x)) smax ( -1 + ( -1 * %y)))) iterations" ; RUN: grep -F "(-2147483632 + (2147483632 smax (-1 + (-1 * %x)) smax (-1 + (-1 * %y)))) iterations"
; PR2607 ; PR2607
define i32 @b(i32 %x, i32 %y) { define i32 @b(i32 %x, i32 %y) {

2
test/Analysis/ScalarEvolution/2008-08-04-IVOverflow.ll
View File

@ -1,5 +1,5 @@
; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \ ; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep -F "Exits: 20028" ; RUN: -scalar-evolution-max-iterations=0 | grep -F "Exits: 20028"
; PR2621 ; PR2621
define i32 @a() nounwind { define i32 @a() nounwind {

2
test/Analysis/ScalarEvolution/2008-08-04-LongAddRec.ll
View File

@ -1,5 +1,5 @@
; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \ ; RUN: llvm-as < %s | opt -analyze -scalar-evolution -disable-output \
; RUN: -scalar-evolution-max-iterations=0 | grep -F "Exits: -19168" ; RUN: -scalar-evolution-max-iterations=0 | grep -F "Exits: -19168"
; PR2621 ; PR2621
define i32 @a() nounwind { define i32 @a() nounwind {

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

@ -1,4 +1,4 @@
; RUN: llvm-as < %s | opt -scalar-evolution -analyze | grep {Loop bb3: ( -1 + %n) iterations!} ; RUN: llvm-as < %s | opt -scalar-evolution -analyze | grep {Loop bb3: (-1 + %n) iterations!}
; 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.

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

@ -1,6 +1,6 @@
; RUN: llvm-as < %s | opt -analyze -scalar-evolution | grep smax | count 2 ; RUN: llvm-as < %s | opt -analyze -scalar-evolution | grep smax | count 2
; RUN: llvm-as < %s | opt -analyze -scalar-evolution | grep \ ; RUN: llvm-as < %s | opt -analyze -scalar-evolution | grep \
; RUN: {%. smax %. smax %.} ; RUN: {%. smax %. smax %.}
; PR1614 ; PR1614
define i32 @x(i32 %a, i32 %b, i32 %c) { define i32 @x(i32 %a, i32 %b, i32 %c) {