maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

eliminate the "Value" printing methods that print to a std::ostream. 

This required converting a bunch of stuff off DOUT and other cleanups.

llvm-svn: 79819
This commit is contained in:
Chris Lattner 2009-08-23 04:37:46 +00:00
parent 82e57a6b48
commit b25de3ff60
35 changed files with 298 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/include/llvm/Analysis/SparsePropagation.h
View File

@ -17,7 +17,6 @@
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallPtrSet.h"
#include <iosfwd>
#include <vector>
#include <set>
@ -32,6 +31,7 @@ namespace llvm {
class Function;
class SparseSolver;
class LLVMContext;
class raw_ostream;
template<typename T> class SmallVectorImpl;
@ -100,7 +100,7 @@ public:
}
/// PrintValue - Render the specified lattice value to the specified stream.
virtual void PrintValue(LatticeVal V, std::ostream &OS);
virtual void PrintValue(LatticeVal V, raw_ostream &OS);
};
@ -141,7 +141,7 @@ public:
///
void Solve(Function &F);
void Print(Function &F, std::ostream &OS) const;
void Print(Function &F, raw_ostream &OS) const;
/// getLatticeState - Return the LatticeVal object that corresponds to the
/// value. If an value is not in the map, it is returned as untracked,

7
llvm/include/llvm/Analysis/Trace.h
View File

@ -20,12 +20,12 @@
#include <vector>
#include <cassert>
#include <iosfwd>
namespace llvm {
class BasicBlock;
class Function;
class Module;
class raw_ostream;
class Trace {
typedef std::vector<BasicBlock *> BasicBlockListType;
@ -106,13 +106,12 @@ public:
/// print - Write trace to output stream.
///
void print (std::ostream &O) const;
void print (std::ostream *O) const { if (O) print(*O); }
void print(raw_ostream &O) const;
/// dump - Debugger convenience method; writes trace to standard error
/// output stream.
///
void dump () const;
void dump() const;
};
} // end namespace llvm

6
llvm/include/llvm/Value.h
View File

@ -19,7 +19,6 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Casting.h"
#include <iosfwd>
#include <string>
namespace llvm {
@ -97,7 +96,6 @@ public:
/// print - Implement operator<< on Value.
///
void print(std::ostream &O, AssemblyAnnotationWriter *AAW = 0) const;
void print(raw_ostream &O, AssemblyAnnotationWriter *AAW = 0) const;
/// All values are typed, get the type of this value.
@ -280,10 +278,6 @@ public:
}
};
inline std::ostream &operator<<(std::ostream &OS, const Value &V) {
V.print(OS);
return OS;
}
inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
V.print(OS);
return OS;

10
llvm/lib/Analysis/AliasAnalysisCounter.cpp
View File

@ -19,7 +19,7 @@
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
static cl::opt<bool>
@ -165,10 +165,10 @@ AliasAnalysisCounter::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
}
if (PrintAll || (PrintAllFailures && R == ModRef)) {
cerr << MRString << ": Ptr: ";
cerr << "[" << Size << "B] ";
WriteAsOperand(*cerr.stream(), P, true, M);
cerr << "\t<->" << *CS.getInstruction();
errs() << MRString << ": Ptr: ";
errs() << "[" << Size << "B] ";
WriteAsOperand(errs(), P, true, M);
errs() << "\t<->" << *CS.getInstruction();
}
return R;
}

18
llvm/lib/Analysis/CFGPrinter.cpp
View File

@ -44,19 +44,21 @@ struct DOTGraphTraits<const Function*> : public DefaultDOTGraphTraits {
if (ShortNames && !Node->getName().empty())
return Node->getNameStr() + ":";
std::ostringstream Out;
std::string Str;
raw_string_ostream OS(Str);
if (ShortNames) {
WriteAsOperand(Out, Node, false);
return Out.str();
WriteAsOperand(OS, Node, false);
return OS.str();
}
if (Node->getName().empty()) {
WriteAsOperand(Out, Node, false);
Out << ":";
WriteAsOperand(OS, Node, false);
OS << ":";
}
Out << *Node;
std::string OutStr = Out.str();
OS << *Node;
std::string OutStr = OS.str();
if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
// Process string output to make it nicer...

8
llvm/lib/Analysis/IVUsers.cpp
View File

@ -228,14 +228,14 @@ bool IVUsers::AddUsersIfInteresting(Instruction *I) {
if (LI->getLoopFor(User->getParent()) != L) {
if (isa<PHINode>(User) || Processed.count(User) ||
!AddUsersIfInteresting(User)) {
DOUT << "FOUND USER in other loop: " << *User << '\n'
<< " OF SCEV: " << *ISE << "\n";
DEBUG(errs() << "FOUND USER in other loop: " << *User << '\n'
<< " OF SCEV: " << *ISE << '\n');
AddUserToIVUsers = true;
}
} else if (Processed.count(User) ||
!AddUsersIfInteresting(User)) {
DOUT << "FOUND USER: " << *User << '\n'
<< " OF SCEV: " << *ISE << "\n";
DEBUG(errs() << "FOUND USER: " << *User << '\n'
<< " OF SCEV: " << *ISE << '\n');
AddUserToIVUsers = true;
}

4
llvm/lib/Analysis/InstCount.cpp
View File

@ -18,7 +18,7 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
@ -47,7 +47,7 @@ namespace {
#include "llvm/Instruction.def"
void visitInstruction(Instruction &I) {
cerr << "Instruction Count does not know about " << I;
errs() << "Instruction Count does not know about " << I;
llvm_unreachable(0);
}
public:

22
llvm/lib/Analysis/Interval.cpp
View File

@ -15,6 +15,7 @@
#include "llvm/Analysis/Interval.h"
#include "llvm/BasicBlock.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
using namespace llvm;
@ -29,29 +30,30 @@ bool Interval::isLoop() const {
// There is a loop in this interval iff one of the predecessors of the header
// node lives in the interval.
for (::pred_iterator I = ::pred_begin(HeaderNode), E = ::pred_end(HeaderNode);
I != E; ++I) {
if (contains(*I)) return true;
}
I != E; ++I)
if (contains(*I))
return true;
return false;
}
void Interval::print(std::ostream &o) const {
o << "-------------------------------------------------------------\n"
void Interval::print(std::ostream &O) const {
raw_os_ostream OS(O);
OS << "-------------------------------------------------------------\n"
<< "Interval Contents:\n";
// Print out all of the basic blocks in the interval...
for (std::vector<BasicBlock*>::const_iterator I = Nodes.begin(),
E = Nodes.end(); I != E; ++I)
o << **I << "\n";
OS << **I << "\n";
o << "Interval Predecessors:\n";
OS << "Interval Predecessors:\n";
for (std::vector<BasicBlock*>::const_iterator I = Predecessors.begin(),
E = Predecessors.end(); I != E; ++I)
o << **I << "\n";
OS << **I << "\n";
o << "Interval Successors:\n";
OS << "Interval Successors:\n";
for (std::vector<BasicBlock*>::const_iterator I = Successors.begin(),
E = Successors.end(); I != E; ++I)
o << **I << "\n";
OS << **I << "\n";
}

4
llvm/lib/Analysis/SparsePropagation.cpp
View File

@ -29,7 +29,7 @@ using namespace llvm;
AbstractLatticeFunction::~AbstractLatticeFunction() {}
/// PrintValue - Render the specified lattice value to the specified stream.
void AbstractLatticeFunction::PrintValue(LatticeVal V, std::ostream &OS) {
void AbstractLatticeFunction::PrintValue(LatticeVal V, raw_ostream &OS) {
if (V == UndefVal)
OS << "undefined";
else if (V == OverdefinedVal)
@ -312,7 +312,7 @@ void SparseSolver::Solve(Function &F) {
}
}
void SparseSolver::Print(Function &F, std::ostream &OS) const {
void SparseSolver::Print(Function &F, raw_ostream &OS) const {
OS << "\nFUNCTION: " << F.getNameStr() << "\n";
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
if (!BBExecutable.count(BB))

8
llvm/lib/Analysis/Trace.cpp
View File

@ -18,7 +18,7 @@
#include "llvm/Analysis/Trace.h"
#include "llvm/Function.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
Function *Trace::getFunction() const {
@ -31,8 +31,8 @@ Module *Trace::getModule() const {
/// print - Write trace to output stream.
///
void Trace::print(std::ostream &O) const {
Function *F = getFunction ();
void Trace::print(raw_ostream &O) const {
Function *F = getFunction();
O << "; Trace from function " << F->getNameStr() << ", blocks:\n";
for (const_iterator i = begin(), e = end(); i != e; ++i) {
O << "; ";
@ -46,5 +46,5 @@ void Trace::print(std::ostream &O) const {
/// output stream.
///
void Trace::dump() const {
print(cerr);
print(errs());
}

4
llvm/lib/CodeGen/MachOWriter.cpp
View File

@ -634,7 +634,7 @@ void MachOWriter::InitMem(const Constant *C, uintptr_t Offset,
}
case Instruction::Add:
default:
cerr << "ConstantExpr not handled as global var init: " << *CE << "\n";
errs() << "ConstantExpr not handled as global var init: " << *CE <<"\n";
llvm_unreachable(0);
}
} else if (PC->getType()->isSingleValueType()) {
@ -732,7 +732,7 @@ void MachOWriter::InitMem(const Constant *C, uintptr_t Offset,
WorkList.push_back(CPair(CPS->getOperand(i),
PA+SL->getElementOffset(i)));
} else {
cerr << "Bad Type: " << *PC->getType() << "\n";
errs() << "Bad Type: " << *PC->getType() << "\n";
llvm_unreachable("Unknown constant type to initialize memory with!");
}
}

82
llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -26,7 +26,6 @@
#include "llvm/Support/MathExtras.h"
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace llvm;
STATISTIC(NumDynamicInsts, "Number of dynamic instructions executed");
@ -57,7 +56,7 @@ static void executeFAddInst(GenericValue &Dest, GenericValue Src1,
IMPLEMENT_BINARY_OPERATOR(+, Float);
IMPLEMENT_BINARY_OPERATOR(+, Double);
default:
cerr << "Unhandled type for FAdd instruction: " << *Ty << "\n";
errs() << "Unhandled type for FAdd instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
}
@ -68,7 +67,7 @@ static void executeFSubInst(GenericValue &Dest, GenericValue Src1,
IMPLEMENT_BINARY_OPERATOR(-, Float);
IMPLEMENT_BINARY_OPERATOR(-, Double);
default:
cerr << "Unhandled type for FSub instruction: " << *Ty << "\n";
errs() << "Unhandled type for FSub instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
}
@ -79,7 +78,7 @@ static void executeFMulInst(GenericValue &Dest, GenericValue Src1,
IMPLEMENT_BINARY_OPERATOR(*, Float);
IMPLEMENT_BINARY_OPERATOR(*, Double);
default:
cerr << "Unhandled type for FMul instruction: " << *Ty << "\n";
errs() << "Unhandled type for FMul instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
}
@ -90,7 +89,7 @@ static void executeFDivInst(GenericValue &Dest, GenericValue Src1,
IMPLEMENT_BINARY_OPERATOR(/, Float);
IMPLEMENT_BINARY_OPERATOR(/, Double);
default:
cerr << "Unhandled type for FDiv instruction: " << *Ty << "\n";
errs() << "Unhandled type for FDiv instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
}
@ -105,7 +104,7 @@ static void executeFRemInst(GenericValue &Dest, GenericValue Src1,
Dest.DoubleVal = fmod(Src1.DoubleVal, Src2.DoubleVal);
break;
default:
cerr << "Unhandled type for Rem instruction: " << *Ty << "\n";
errs() << "Unhandled type for Rem instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
}
@ -132,7 +131,7 @@ static GenericValue executeICMP_EQ(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(eq,Ty);
IMPLEMENT_POINTER_ICMP(==);
default:
cerr << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_EQ predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -145,7 +144,7 @@ static GenericValue executeICMP_NE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(ne,Ty);
IMPLEMENT_POINTER_ICMP(!=);
default:
cerr << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_NE predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -158,7 +157,7 @@ static GenericValue executeICMP_ULT(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(ult,Ty);
IMPLEMENT_POINTER_ICMP(<);
default:
cerr << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_ULT predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -171,7 +170,7 @@ static GenericValue executeICMP_SLT(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(slt,Ty);
IMPLEMENT_POINTER_ICMP(<);
default:
cerr << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_SLT predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -184,7 +183,7 @@ static GenericValue executeICMP_UGT(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(ugt,Ty);
IMPLEMENT_POINTER_ICMP(>);
default:
cerr << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_UGT predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -197,7 +196,7 @@ static GenericValue executeICMP_SGT(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(sgt,Ty);
IMPLEMENT_POINTER_ICMP(>);
default:
cerr << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_SGT predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -210,7 +209,7 @@ static GenericValue executeICMP_ULE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(ule,Ty);
IMPLEMENT_POINTER_ICMP(<=);
default:
cerr << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_ULE predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -223,7 +222,7 @@ static GenericValue executeICMP_SLE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(sle,Ty);
IMPLEMENT_POINTER_ICMP(<=);
default:
cerr << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_SLE predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -236,7 +235,7 @@ static GenericValue executeICMP_UGE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(uge,Ty);
IMPLEMENT_POINTER_ICMP(>=);
default:
cerr << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_UGE predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -249,7 +248,7 @@ static GenericValue executeICMP_SGE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_INTEGER_ICMP(sge,Ty);
IMPLEMENT_POINTER_ICMP(>=);
default:
cerr << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n";
errs() << "Unhandled type for ICMP_SGE predicate: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -274,7 +273,7 @@ void Interpreter::visitICmpInst(ICmpInst &I) {
case ICmpInst::ICMP_UGE: R = executeICMP_UGE(Src1, Src2, Ty); break;
case ICmpInst::ICMP_SGE: R = executeICMP_SGE(Src1, Src2, Ty); break;
default:
cerr << "Don't know how to handle this ICmp predicate!\n-->" << I;
errs() << "Don't know how to handle this ICmp predicate!\n-->" << I;
llvm_unreachable(0);
}
@ -293,7 +292,7 @@ static GenericValue executeFCMP_OEQ(GenericValue Src1, GenericValue Src2,
IMPLEMENT_FCMP(==, Float);
IMPLEMENT_FCMP(==, Double);
default:
cerr << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n";
errs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -307,7 +306,7 @@ static GenericValue executeFCMP_ONE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_FCMP(!=, Double);
default:
cerr << "Unhandled type for FCmp NE instruction: " << *Ty << "\n";
errs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -320,7 +319,7 @@ static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_FCMP(<=, Float);
IMPLEMENT_FCMP(<=, Double);
default:
cerr << "Unhandled type for FCmp LE instruction: " << *Ty << "\n";
errs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -333,7 +332,7 @@ static GenericValue executeFCMP_OGE(GenericValue Src1, GenericValue Src2,
IMPLEMENT_FCMP(>=, Float);
IMPLEMENT_FCMP(>=, Double);
default:
cerr << "Unhandled type for FCmp GE instruction: " << *Ty << "\n";
errs() << "Unhandled type for FCmp GE instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -346,7 +345,7 @@ static GenericValue executeFCMP_OLT(GenericValue Src1, GenericValue Src2,
IMPLEMENT_FCMP(<, Float);
IMPLEMENT_FCMP(<, Double);
default:
cerr << "Unhandled type for FCmp LT instruction: " << *Ty << "\n";
errs() << "Unhandled type for FCmp LT instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -359,7 +358,7 @@ static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2,
IMPLEMENT_FCMP(>, Float);
IMPLEMENT_FCMP(>, Double);
default:
cerr << "Unhandled type for FCmp GT instruction: " << *Ty << "\n";
errs() << "Unhandled type for FCmp GT instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
return Dest;
@ -468,7 +467,7 @@ void Interpreter::visitFCmpInst(FCmpInst &I) {
case FCmpInst::FCMP_UGE: R = executeFCMP_UGE(Src1, Src2, Ty); break;
case FCmpInst::FCMP_OGE: R = executeFCMP_OGE(Src1, Src2, Ty); break;
default:
cerr << "Don't know how to handle this FCmp predicate!\n-->" << I;
errs() << "Don't know how to handle this FCmp predicate!\n-->" << I;
llvm_unreachable(0);
}
@ -514,7 +513,7 @@ static GenericValue executeCmpInst(unsigned predicate, GenericValue Src1,
return Result;
}
default:
cerr << "Unhandled Cmp predicate\n";
errs() << "Unhandled Cmp predicate\n";
llvm_unreachable(0);
}
}
@ -543,7 +542,7 @@ void Interpreter::visitBinaryOperator(BinaryOperator &I) {
case Instruction::Or: R.IntVal = Src1.IntVal | Src2.IntVal; break;
case Instruction::Xor: R.IntVal = Src1.IntVal ^ Src2.IntVal; break;
default:
cerr << "Don't know how to handle this binary operator!\n-->" << I;
errs() << "Don't know how to handle this binary operator!\n-->" << I;
llvm_unreachable(0);
}
@ -814,7 +813,7 @@ void Interpreter::visitLoadInst(LoadInst &I) {
LoadValueFromMemory(Result, Ptr, I.getType());
SetValue(&I, Result, SF);
if (I.isVolatile() && PrintVolatile)
cerr << "Volatile load " << I;
errs() << "Volatile load " << I;
}
void Interpreter::visitStoreInst(StoreInst &I) {
@ -824,7 +823,7 @@ void Interpreter::visitStoreInst(StoreInst &I) {
StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
I.getOperand(0)->getType());
if (I.isVolatile() && PrintVolatile)
cerr << "Volatile store: " << I;
errs() << "Volatile store: " << I;
}
//===----------------------------------------------------------------------===//
@ -1178,7 +1177,7 @@ void Interpreter::visitVAArgInst(VAArgInst &I) {
IMPLEMENT_VAARG(Float);
IMPLEMENT_VAARG(Double);
default:
cerr << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
errs() << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
llvm_unreachable(0);
}
@ -1265,7 +1264,7 @@ GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue());
break;
default:
cerr << "Unhandled ConstantExpr: " << *CE << "\n";
errs() << "Unhandled ConstantExpr: " << *CE << "\n";
llvm_unreachable(0);
return GenericValue();
}
@ -1338,30 +1337,29 @@ void Interpreter::run() {
// Track the number of dynamic instructions executed.
++NumDynamicInsts;
DOUT << "About to interpret: " << I;
DEBUG(errs() << "About to interpret: " << I);
visit(I); // Dispatch to one of the visit* methods...
#if 0
// This is not safe, as visiting the instruction could lower it and free I.
#ifndef NDEBUG
DEBUG(
if (!isa<CallInst>(I) && !isa<InvokeInst>(I) &&
I.getType() != Type::VoidTy) {
DOUT << " --> ";
errs() << " --> ";
const GenericValue &Val = SF.Values[&I];
switch (I.getType()->getTypeID()) {
default: llvm_unreachable("Invalid GenericValue Type");
case Type::VoidTyID: DOUT << "void"; break;
case Type::FloatTyID: DOUT << "float " << Val.FloatVal; break;
case Type::DoubleTyID: DOUT << "double " << Val.DoubleVal; break;
case Type::PointerTyID: DOUT << "void* " << intptr_t(Val.PointerVal);
case Type::VoidTyID: errs() << "void"; break;
case Type::FloatTyID: errs() << "float " << Val.FloatVal; break;
case Type::DoubleTyID: errs() << "double " << Val.DoubleVal; break;
case Type::PointerTyID: errs() << "void* " << intptr_t(Val.PointerVal);
break;
case Type::IntegerTyID:
DOUT << "i" << Val.IntVal.getBitWidth() << " "
<< Val.IntVal.toStringUnsigned(10)
<< " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n";
errs() << "i" << Val.IntVal.getBitWidth() << " "
<< Val.IntVal.toStringUnsigned(10)
<< " (0x" << Val.IntVal.toStringUnsigned(16) << ")\n";
break;
}
}
#endif
});
#endif
}
}

8
llvm/lib/ExecutionEngine/Interpreter/Interpreter.h
View File

@ -17,12 +17,12 @@
#include "llvm/Function.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/CallSite.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Support/CallSite.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/raw_ostream.h"
namespace llvm {
class IntrinsicLowering;
@ -174,7 +174,7 @@ public:
void visitVAArgInst(VAArgInst &I);
void visitInstruction(Instruction &I) {
cerr << I;
errs() << I;
llvm_unreachable("Instruction not interpretable yet!");
}

17
llvm/lib/Linker/LinkModules.cpp
View File

@ -25,7 +25,6 @@
#include "llvm/ValueSymbolTable.h"
#include "llvm/Instructions.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/System/Path.h"
#include "llvm/ADT/DenseMap.h"
@ -145,7 +144,7 @@ protected:
// for debugging...
virtual void dump() const {
cerr << "AbstractTypeSet!\n";
errs() << "AbstractTypeSet!\n";
}
};
}
@ -338,11 +337,11 @@ static bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) {
static void PrintMap(const std::map<const Value*, Value*> &M) {
for (std::map<const Value*, Value*>::const_iterator I = M.begin(), E =M.end();
I != E; ++I) {
cerr << " Fr: " << (void*)I->first << " ";
errs() << " Fr: " << (void*)I->first << " ";
I->first->dump();
cerr << " To: " << (void*)I->second << " ";
errs() << " To: " << (void*)I->second << " ";
I->second->dump();
cerr << "\n";
errs() << "\n";
}
}
#endif
@ -414,10 +413,10 @@ static Value *RemapOperand(const Value *In,
}
#ifndef NDEBUG
cerr << "LinkModules ValueMap: \n";
errs() << "LinkModules ValueMap: \n";
PrintMap(ValueMap);
cerr << "Couldn't remap value: " << (void*)In << " " << *In << "\n";
errs() << "Couldn't remap value: " << (void*)In << " " << *In << "\n";
llvm_unreachable("Couldn't remap value!");
#endif
return 0;
@ -1280,10 +1279,10 @@ Linker::LinkModules(Module *Dest, Module *Src, std::string *ErrorMsg) {
if (!Src->getDataLayout().empty() && !Dest->getDataLayout().empty() &&
Src->getDataLayout() != Dest->getDataLayout())
cerr << "WARNING: Linking two modules of different data layouts!\n";
errs() << "WARNING: Linking two modules of different data layouts!\n";
if (!Src->getTargetTriple().empty() &&
Dest->getTargetTriple() != Src->getTargetTriple())
cerr << "WARNING: Linking two modules of different target triples!\n";
errs() << "WARNING: Linking two modules of different target triples!\n";
// Append the module inline asm string.
if (!Src->getModuleInlineAsm().empty()) {

14
llvm/lib/Target/CBackend/CBackend.cpp
View File

@ -319,7 +319,7 @@ namespace {
void visitInstruction(Instruction &I) {
#ifndef NDEBUG
cerr << "C Writer does not know about " << I;
errs() << "C Writer does not know about " << I;
#endif
llvm_unreachable(0);
}
@ -506,7 +506,7 @@ CWriter::printSimpleType(formatted_raw_ostream &Out, const Type *Ty,
default:
#ifndef NDEBUG
cerr << "Unknown primitive type: " << *Ty << "\n";
errs() << "Unknown primitive type: " << *Ty << "\n";
#endif
llvm_unreachable(0);
}
@ -553,7 +553,7 @@ CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned,
default:
#ifndef NDEBUG
cerr << "Unknown primitive type: " << *Ty << "\n";
errs() << "Unknown primitive type: " << *Ty << "\n";
#endif
llvm_unreachable(0);
}
@ -1110,7 +1110,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
}
default:
#ifndef NDEBUG
cerr << "CWriter Error: Unhandled constant expression: "
errs() << "CWriter Error: Unhandled constant expression: "
<< *CE << "\n";
#endif
llvm_unreachable(0);
@ -1323,7 +1323,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
// FALL THROUGH
default:
#ifndef NDEBUG
cerr << "Unknown constant type: " << *CPV << "\n";
errs() << "Unknown constant type: " << *CPV << "\n";
#endif
llvm_unreachable(0);
}
@ -2735,7 +2735,7 @@ void CWriter::visitBinaryOperator(Instruction &I) {
case Instruction::AShr: Out << " >> "; break;
default:
#ifndef NDEBUG
cerr << "Invalid operator type!" << I;
errs() << "Invalid operator type!" << I;
#endif
llvm_unreachable(0);
}
@ -2776,7 +2776,7 @@ void CWriter::visitICmpInst(ICmpInst &I) {
case ICmpInst::ICMP_SGT: Out << " > "; break;
default:
#ifndef NDEBUG
cerr << "Invalid icmp predicate!" << I;
errs() << "Invalid icmp predicate!" << I;
#endif
llvm_unreachable(0);
}

18
llvm/lib/Target/MSIL/MSILWriter.cpp
View File

@ -281,7 +281,7 @@ std::string MSILWriter::getConvModopt(unsigned CallingConvID) {
case CallingConv::X86_StdCall:
return "modopt([mscorlib]System.Runtime.CompilerServices.CallConvStdcall) ";
default:
cerr << "CallingConvID = " << CallingConvID << '\n';
errs() << "CallingConvID = " << CallingConvID << '\n';
llvm_unreachable("Unsupported calling convention");
}
return ""; // Not reached
@ -327,7 +327,7 @@ std::string MSILWriter::getPrimitiveTypeName(const Type* Ty, bool isSigned) {
case Type::DoubleTyID:
return "float64 ";
default:
cerr << "Type = " << *Ty << '\n';
errs() << "Type = " << *Ty << '\n';
llvm_unreachable("Invalid primitive type");
}
return ""; // Not reached
@ -355,7 +355,7 @@ std::string MSILWriter::getTypeName(const Type* Ty, bool isSigned,
return getArrayTypeName(Ty->getTypeID(),Ty);
return "valuetype '"+getArrayTypeName(Ty->getTypeID(),Ty)+"' ";
default:
cerr << "Type = " << *Ty << '\n';
errs() << "Type = " << *Ty << '\n';
llvm_unreachable("Invalid type in getTypeName()");
}
return ""; // Not reached
@ -399,7 +399,7 @@ std::string MSILWriter::getTypePostfix(const Type* Ty, bool Expand,
case Type::PointerTyID:
return "i"+utostr(TD->getTypeAllocSize(Ty));
default:
cerr << "TypeID = " << Ty->getTypeID() << '\n';
errs() << "TypeID = " << Ty->getTypeID() << '\n';
llvm_unreachable("Invalid type in TypeToPostfix()");
}
return ""; // Not reached
@ -426,7 +426,7 @@ void MSILWriter::printPtrLoad(uint64_t N) {
printSimpleInstruction("ldc.i4",utostr(N).c_str());
// FIXME: Need overflow test?
if (!isUInt32(N)) {
cerr << "Value = " << utostr(N) << '\n';
errs() << "Value = " << utostr(N) << '\n';
llvm_unreachable("32-bit pointer overflowed");
}
break;
@ -469,7 +469,7 @@ void MSILWriter::printConstLoad(const Constant* C) {
// Undefined constant value = NULL.
printPtrLoad(0);
} else {
cerr << "Constant = " << *C << '\n';
errs() << "Constant = " << *C << '\n';
llvm_unreachable("Invalid constant value");
}
Out << '\n';
@ -518,7 +518,7 @@ void MSILWriter::printValueLoad(const Value* V) {
printConstantExpr(cast<ConstantExpr>(V));
break;
default:
cerr << "Value = " << *V << '\n';
errs() << "Value = " << *V << '\n';
llvm_unreachable("Invalid value location");
}
}
@ -533,7 +533,7 @@ void MSILWriter::printValueSave(const Value* V) {
printSimpleInstruction("stloc",getValueName(V).c_str());
break;
default:
cerr << "Value = " << *V << '\n';
errs() << "Value = " << *V << '\n';
llvm_unreachable("Invalid value location");
}
}
@ -695,7 +695,7 @@ void MSILWriter::printCastInstruction(unsigned int Op, const Value* V,
// FIXME: meaning that ld*/st* instruction do not change data format.
break;
default:
cerr << "Opcode = " << Op << '\n';
errs() << "Opcode = " << Op << '\n';
llvm_unreachable("Invalid conversion instruction");
}
}

28
llvm/lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -552,7 +552,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV, const TargetData &TD,
if (NewGlobals.empty())
return 0;
DOUT << "PERFORMING GLOBAL SRA ON: " << *GV;
DEBUG(errs() << "PERFORMING GLOBAL SRA ON: " << *GV);
Constant *NullInt = Constant::getNullValue(Type::getInt32Ty(Context));
@ -781,14 +781,14 @@ static bool OptimizeAwayTrappingUsesOfLoads(GlobalVariable *GV, Constant *LV,
}
if (Changed) {
DOUT << "OPTIMIZED LOADS FROM STORED ONCE POINTER: " << *GV;
DEBUG(errs() << "OPTIMIZED LOADS FROM STORED ONCE POINTER: " << *GV);
++NumGlobUses;
}
// If we nuked all of the loads, then none of the stores are needed either,
// nor is the global.
if (AllNonStoreUsesGone) {
DOUT << " *** GLOBAL NOW DEAD!\n";
DEBUG(errs() << " *** GLOBAL NOW DEAD!\n");
CleanupConstantGlobalUsers(GV, 0, Context);
if (GV->use_empty()) {
GV->eraseFromParent();
@ -823,7 +823,7 @@ static void ConstantPropUsersOf(Value *V, LLVMContext &Context) {
static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
MallocInst *MI,
LLVMContext &Context) {
DOUT << "PROMOTING MALLOC GLOBAL: " << *GV << " MALLOC = " << *MI;
DEBUG(errs() << "PROMOTING MALLOC GLOBAL: " << *GV << " MALLOC = " << *MI);
ConstantInt *NElements = cast<ConstantInt>(MI->getArraySize());
if (NElements->getZExtValue() != 1) {
@ -1269,7 +1269,7 @@ static void RewriteUsesOfLoadForHeapSRoA(LoadInst *Load,
/// it up into multiple allocations of arrays of the fields.
static GlobalVariable *PerformHeapAllocSRoA(GlobalVariable *GV, MallocInst *MI,
LLVMContext &Context){
DOUT << "SROA HEAP ALLOC: " << *GV << " MALLOC = " << *MI;
DEBUG(errs() << "SROA HEAP ALLOC: " << *GV << " MALLOC = " << *MI);
const StructType *STy = cast<StructType>(MI->getAllocatedType());
// There is guaranteed to be at least one use of the malloc (storing
@ -1587,7 +1587,7 @@ static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal,
if (!isa<LoadInst>(I) && !isa<StoreInst>(I))
return false;
DOUT << " *** SHRINKING TO BOOL: " << *GV;
DEBUG(errs() << " *** SHRINKING TO BOOL: " << *GV);
// Create the new global, initializing it to false.
GlobalVariable *NewGV = new GlobalVariable(Context,
@ -1666,7 +1666,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
GV->removeDeadConstantUsers();
if (GV->use_empty()) {
DOUT << "GLOBAL DEAD: " << *GV;
DEBUG(errs() << "GLOBAL DEAD: " << *GV);
GV->eraseFromParent();
++NumDeleted;
return true;
@ -1709,7 +1709,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
GS.AccessingFunction->getName() == "main" &&
GS.AccessingFunction->hasExternalLinkage() &&
GV->getType()->getAddressSpace() == 0) {
DOUT << "LOCALIZING GLOBAL: " << *GV;
DEBUG(errs() << "LOCALIZING GLOBAL: " << *GV);
Instruction* FirstI = GS.AccessingFunction->getEntryBlock().begin();
const Type* ElemTy = GV->getType()->getElementType();
// FIXME: Pass Global's alignment when globals have alignment
@ -1726,7 +1726,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
// If the global is never loaded (but may be stored to), it is dead.
// Delete it now.
if (!GS.isLoaded) {
DOUT << "GLOBAL NEVER LOADED: " << *GV;
DEBUG(errs() << "GLOBAL NEVER LOADED: " << *GV);
// Delete any stores we can find to the global. We may not be able to
// make it completely dead though.
@ -1742,7 +1742,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
return Changed;
} else if (GS.StoredType <= GlobalStatus::isInitializerStored) {
DOUT << "MARKING CONSTANT: " << *GV;
DEBUG(errs() << "MARKING CONSTANT: " << *GV);
GV->setConstant(true);
// Clean up any obviously simplifiable users now.
@ -1750,8 +1750,8 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
// If the global is dead now, just nuke it.
if (GV->use_empty()) {
DOUT << " *** Marking constant allowed us to simplify "
<< "all users and delete global!\n";
DEBUG(errs() << " *** Marking constant allowed us to simplify "
<< "all users and delete global!\n");
GV->eraseFromParent();
++NumDeleted;
}
@ -1780,8 +1780,8 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
GV->getContext());
if (GV->use_empty()) {
DOUT << " *** Substituting initializer allowed us to "
<< "simplify all users and delete global!\n";
DEBUG(errs() << " *** Substituting initializer allowed us to "
<< "simplify all users and delete global!\n");
GV->eraseFromParent();
++NumDeleted;
} else {

6
llvm/lib/Transforms/Scalar/CodeGenPrepare.cpp
View File

@ -231,7 +231,7 @@ void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) {
BranchInst *BI = cast<BranchInst>(BB->getTerminator());
BasicBlock *DestBB = BI->getSuccessor(0);
DOUT << "MERGING MOSTLY EMPTY BLOCKS - BEFORE:\n" << *BB << *DestBB;
DEBUG(errs() << "MERGING MOSTLY EMPTY BLOCKS - BEFORE:\n" << *BB << *DestBB);
// If the destination block has a single pred, then this is a trivial edge,
// just collapse it.
@ -245,7 +245,7 @@ void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) {
if (isEntry && BB != &BB->getParent()->getEntryBlock())
BB->moveBefore(&BB->getParent()->getEntryBlock());
DOUT << "AFTER:\n" << *DestBB << "\n\n\n";
DEBUG(errs() << "AFTER:\n" << *DestBB << "\n\n\n");
return;
}
}
@ -284,7 +284,7 @@ void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) {
BB->replaceAllUsesWith(DestBB);
BB->eraseFromParent();
DOUT << "AFTER:\n" << *DestBB << "\n\n\n";
DEBUG(errs() << "AFTER:\n" << *DestBB << "\n\n\n");
}

23
llvm/lib/Transforms/Scalar/IndVarSimplify.cpp
View File

@ -52,10 +52,11 @@
#include "llvm/Analysis/LoopPass.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/STLExtras.h"
@ -182,11 +183,11 @@ ICmpInst *IndVarSimplify::LinearFunctionTestReplace(Loop *L,
else
Opcode = ICmpInst::ICMP_EQ;
DOUT << "INDVARS: Rewriting loop exit condition to:\n"
<< " LHS:" << *CmpIndVar << '\n'
<< " op:\t"
<< (Opcode == ICmpInst::ICMP_NE ? "!=" : "==") << "\n"
<< " RHS:\t" << *RHS << "\n";
DEBUG(errs() << "INDVARS: Rewriting loop exit condition to:\n"
<< " LHS:" << *CmpIndVar << '\n'
<< " op:\t"
<< (Opcode == ICmpInst::ICMP_NE ? "!=" : "==") << "\n"
<< " RHS:\t" << *RHS << "\n");
ICmpInst *Cond = new ICmpInst(BI, Opcode, CmpIndVar, ExitCnt, "exitcond");
@ -273,8 +274,8 @@ void IndVarSimplify::RewriteLoopExitValues(Loop *L,
Value *ExitVal = Rewriter.expandCodeFor(ExitValue, PN->getType(), Inst);
DOUT << "INDVARS: RLEV: AfterLoopVal = " << *ExitVal << '\n'
<< " LoopVal = " << *Inst << "\n";
DEBUG(errs() << "INDVARS: RLEV: AfterLoopVal = " << *ExitVal << '\n'
<< " LoopVal = " << *Inst << "\n");
PN->setIncomingValue(i, ExitVal);
@ -401,7 +402,7 @@ bool IndVarSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
++NumInserted;
Changed = true;
DOUT << "INDVARS: New CanIV: " << *IndVar << '\n';
DEBUG(errs() << "INDVARS: New CanIV: " << *IndVar << '\n');
// Now that the official induction variable is established, reinsert
// the old canonical-looking variable after it so that the IR remains
@ -506,8 +507,8 @@ void IndVarSimplify::RewriteIVExpressions(Loop *L, const Type *LargestType,
NewVal->takeName(Op);
User->replaceUsesOfWith(Op, NewVal);
UI->setOperandValToReplace(NewVal);
DOUT << "INDVARS: Rewrote IV '" << *AR << "' " << *Op << '\n'
<< " into = " << *NewVal << "\n";
DEBUG(errs() << "INDVARS: Rewrote IV '" << *AR << "' " << *Op << '\n'
<< " into = " << *NewVal << "\n");
++NumRemoved;
Changed = true;

27
llvm/lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -7831,7 +7831,7 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
++UI; // If this instruction uses AI more than once, don't break UI.
++NumDeadInst;
DOUT << "IC: DCE: " << *User << '\n';
DEBUG(errs() << "IC: DCE: " << *User << '\n');
EraseInstFromFunction(*User);
}
}
@ -8387,8 +8387,8 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
}
if (DoXForm) {
DOUT << "ICE: EvaluateInDifferentType converting expression type to avoid"
<< " cast: " << CI;
DEBUG(errs() << "ICE: EvaluateInDifferentType converting expression type"
" to avoid cast: " << CI);
Value *Res = EvaluateInDifferentType(SrcI, DestTy,
CI.getOpcode() == Instruction::SExt);
if (JustReplace)
@ -12915,14 +12915,15 @@ static void AddReachableCodeToWorklist(BasicBlock *BB,
// DCE instruction if trivially dead.
if (isInstructionTriviallyDead(Inst)) {
++NumDeadInst;
DOUT << "IC: DCE: " << *Inst << '\n';
DEBUG(errs() << "IC: DCE: " << *Inst << '\n');
Inst->eraseFromParent();
continue;
}
// ConstantProp instruction if trivially constant.
if (Constant *C = ConstantFoldInstruction(Inst, BB->getContext(), TD)) {
DOUT << "IC: ConstFold to: " << *C << " from: " << *Inst << '\n';
DEBUG(errs() << "IC: ConstFold to: " << *C << " from: "
<< *Inst << '\n');
Inst->replaceAllUsesWith(C);
++NumConstProp;
Inst->eraseFromParent();
@ -13002,7 +13003,7 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
while (Term != BB->begin()) { // Remove instrs bottom-up
BasicBlock::iterator I = Term; --I;
DOUT << "IC: DCE: " << *I << '\n';
DEBUG(errs() << "IC: DCE: " << *I << '\n');
// A debug intrinsic shouldn't force another iteration if we weren't
// going to do one without it.
if (!isa<DbgInfoIntrinsic>(I)) {
@ -13027,7 +13028,7 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
AddUsesToWorkList(*I);
++NumDeadInst;
DOUT << "IC: DCE: " << *I << '\n';
DEBUG(errs() << "IC: DCE: " << *I << '\n');
I->eraseFromParent();
RemoveFromWorkList(I);
@ -13037,7 +13038,7 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
// Instruction isn't dead, see if we can constant propagate it.
if (Constant *C = ConstantFoldInstruction(I, F.getContext(), TD)) {
DOUT << "IC: ConstFold to: " << *C << " from: " << *I << '\n';
DEBUG(errs() << "IC: ConstFold to: " << *C << " from: " << *I << '\n');
// Add operands to the worklist.
AddUsesToWorkList(*I);
@ -13089,13 +13090,13 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
#ifndef NDEBUG
std::string OrigI;
#endif
DEBUG(std::ostringstream SS; I->print(SS); OrigI = SS.str(););
DEBUG(raw_string_ostream SS(OrigI); I->print(SS); OrigI = SS.str(););
if (Instruction *Result = visit(*I)) {
++NumCombined;
// Should we replace the old instruction with a new one?
if (Result != I) {
DOUT << "IC: Old = " << *I << '\n'
<< " New = " << *Result << '\n';
DEBUG(errs() << "IC: Old = " << *I << '\n'
<< " New = " << *Result << '\n');
// Everything uses the new instruction now.
I->replaceAllUsesWith(Result);
@ -13129,8 +13130,8 @@ bool InstCombiner::DoOneIteration(Function &F, unsigned Iteration) {
InstParent->getInstList().erase(I);
} else {
#ifndef NDEBUG
DOUT << "IC: Mod = " << OrigI << '\n'
<< " New = " << *I << '\n';
DEBUG(errs() << "IC: Mod = " << OrigI << '\n'
<< " New = " << *I << '\n');
#endif
// If the instruction was modified, it's possible that it is now dead.

4
llvm/lib/Transforms/Scalar/LICM.cpp
View File

@ -466,7 +466,7 @@ bool LICM::isLoopInvariantInst(Instruction &I) {
/// position, and may either delete it or move it to outside of the loop.
///
void LICM::sink(Instruction &I) {
DOUT << "LICM sinking instruction: " << I;
DEBUG(errs() << "LICM sinking instruction: " << I);
SmallVector<BasicBlock*, 8> ExitBlocks;
CurLoop->getExitBlocks(ExitBlocks);
@ -860,7 +860,7 @@ void LICM::FindPromotableValuesInLoop(
for (AliasSet::iterator I = AS.begin(), E = AS.end(); I != E; ++I)
ValueToAllocaMap.insert(std::make_pair(I->getValue(), AI));
DOUT << "LICM: Promoting value: " << *V << "\n";
DEBUG(errs() << "LICM: Promoting value: " << *V << "\n");
}
}

60
llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp
View File

@ -380,9 +380,9 @@ namespace {
}
void BasedUser::dump() const {
cerr << " Base=" << *Base;
cerr << " Imm=" << *Imm;
cerr << " Inst: " << *Inst;
errs() << " Base=" << *Base;
errs() << " Imm=" << *Imm;
errs() << " Inst: " << *Inst;
}
Value *BasedUser::InsertCodeForBaseAtPosition(const SCEV *const &NewBase,
@ -461,9 +461,10 @@ void BasedUser::RewriteInstructionToUseNewBase(const SCEV *const &NewBase,
// Replace the use of the operand Value with the new Phi we just created.
Inst->replaceUsesOfWith(OperandValToReplace, NewVal);
DOUT << " Replacing with ";
DEBUG(WriteAsOperand(*DOUT, NewVal, /*PrintType=*/false));
DOUT << ", which has value " << *NewBase << " plus IMM " << *Imm << "\n";
DEBUG(errs() << " Replacing with ");
DEBUG(WriteAsOperand(errs(), NewVal, /*PrintType=*/false));
DEBUG(errs() << ", which has value " << *NewBase << " plus IMM "
<< *Imm << "\n");
return;
}
@ -518,9 +519,10 @@ void BasedUser::RewriteInstructionToUseNewBase(const SCEV *const &NewBase,
Code = InsertCodeForBaseAtPosition(NewBase, PN->getType(),
Rewriter, InsertPt, L, LI);
DOUT << " Changing PHI use to ";
DEBUG(WriteAsOperand(*DOUT, Code, /*PrintType=*/false));
DOUT << ", which has value " << *NewBase << " plus IMM " << *Imm << "\n";
DEBUG(errs() << " Changing PHI use to ");
DEBUG(WriteAsOperand(errs(), Code, /*PrintType=*/false));
DEBUG(errs() << ", which has value " << *NewBase << " plus IMM "
<< *Imm << "\n");
}
// Replace the use of the operand Value with the new Phi we just created.
@ -1373,7 +1375,7 @@ LoopStrengthReduce::PrepareToStrengthReduceFully(
const SCEV *CommonExprs,
const Loop *L,
SCEVExpander &PreheaderRewriter) {
DOUT << " Fully reducing all users\n";
DEBUG(errs() << " Fully reducing all users\n");
// Rewrite the UsersToProcess records, creating a separate PHI for each
// unique Base value.
@ -1422,7 +1424,7 @@ LoopStrengthReduce::PrepareToStrengthReduceWithNewPhi(
Instruction *IVIncInsertPt,
const Loop *L,
SCEVExpander &PreheaderRewriter) {
DOUT << " Inserting new PHI:\n";
DEBUG(errs() << " Inserting new PHI:\n");
PHINode *Phi = InsertAffinePhi(SE->getUnknown(CommonBaseV),
Stride, IVIncInsertPt, L,
@ -1435,9 +1437,9 @@ LoopStrengthReduce::PrepareToStrengthReduceWithNewPhi(
for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i)
UsersToProcess[i].Phi = Phi;
DOUT << " IV=";
DEBUG(WriteAsOperand(*DOUT, Phi, /*PrintType=*/false));
DOUT << "\n";
DEBUG(errs() << " IV=");
DEBUG(WriteAsOperand(errs(), Phi, /*PrintType=*/false));
DEBUG(errs() << "\n");
}
/// PrepareToStrengthReduceFromSmallerStride - Prepare for the given users to
@ -1450,8 +1452,8 @@ LoopStrengthReduce::PrepareToStrengthReduceFromSmallerStride(
Value *CommonBaseV,
const IVExpr &ReuseIV,
Instruction *PreInsertPt) {
DOUT << " Rewriting in terms of existing IV of STRIDE " << *ReuseIV.Stride
<< " and BASE " << *ReuseIV.Base << "\n";
DEBUG(errs() << " Rewriting in terms of existing IV of STRIDE "
<< *ReuseIV.Stride << " and BASE " << *ReuseIV.Base << "\n");
// All the users will share the reused IV.
for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i)
@ -1558,7 +1560,7 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(const SCEV *const &Stride,
UsersToProcess, TLI);
if (DoSink) {
DOUT << " Sinking " << *Imm << " back down into uses\n";
DEBUG(errs() << " Sinking " << *Imm << " back down into uses\n");
for (unsigned i = 0, e = UsersToProcess.size(); i != e; ++i)
UsersToProcess[i].Imm = SE->getAddExpr(UsersToProcess[i].Imm, Imm);
CommonExprs = NewCommon;
@ -1570,9 +1572,9 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(const SCEV *const &Stride,
// Now that we know what we need to do, insert the PHI node itself.
//
DOUT << "LSR: Examining IVs of TYPE " << *ReplacedTy << " of STRIDE "
<< *Stride << ":\n"
<< " Common base: " << *CommonExprs << "\n";
DEBUG(errs() << "LSR: Examining IVs of TYPE " << *ReplacedTy << " of STRIDE "
<< *Stride << ":\n"
<< " Common base: " << *CommonExprs << "\n");
SCEVExpander Rewriter(*SE);
SCEVExpander PreheaderRewriter(*SE);
@ -1634,10 +1636,10 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(const SCEV *const &Stride,
if (!Base->isZero()) {
BaseV = PreheaderRewriter.expandCodeFor(Base, 0, PreInsertPt);
DOUT << " INSERTING code for BASE = " << *Base << ":";
DEBUG(errs() << " INSERTING code for BASE = " << *Base << ":");
if (BaseV->hasName())
DOUT << " Result value name = %" << BaseV->getNameStr();
DOUT << "\n";
DEBUG(errs() << " Result value name = %" << BaseV->getName());
DEBUG(errs() << "\n");
// If BaseV is a non-zero constant, make sure that it gets inserted into
// the preheader, instead of being forward substituted into the uses. We
@ -1658,15 +1660,15 @@ void LoopStrengthReduce::StrengthReduceStridedIVUsers(const SCEV *const &Stride,
// FIXME: Use emitted users to emit other users.
BasedUser &User = UsersToProcess.back();
DOUT << " Examining ";
DEBUG(errs() << " Examining ");
if (User.isUseOfPostIncrementedValue)
DOUT << "postinc";
DEBUG(errs() << "postinc");
else
DOUT << "preinc";
DOUT << " use ";
DEBUG(WriteAsOperand(*DOUT, UsersToProcess.back().OperandValToReplace,
DEBUG(errs() << "preinc");
DEBUG(errs() << " use ");
DEBUG(WriteAsOperand(errs(), UsersToProcess.back().OperandValToReplace,
/*PrintType=*/false));
DOUT << " in Inst: " << *(User.Inst);
DEBUG(errs() << " in Inst: " << *User.Inst);
// If this instruction wants to use the post-incremented value, move it
// after the post-inc and use its value instead of the PHI.

8
llvm/lib/Transforms/Scalar/LoopUnswitch.cpp
View File

@ -751,7 +751,7 @@ static void RemoveFromWorklist(Instruction *I,
static void ReplaceUsesOfWith(Instruction *I, Value *V,
std::vector<Instruction*> &Worklist,
Loop *L, LPPassManager *LPM) {
DOUT << "Replace with '" << *V << "': " << *I;
DEBUG(errs() << "Replace with '" << *V << "': " << *I);
// Add uses to the worklist, which may be dead now.
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
@ -813,7 +813,7 @@ void LoopUnswitch::RemoveBlockIfDead(BasicBlock *BB,
return;
}
DOUT << "Nuking dead block: " << *BB;
DEBUG(errs() << "Nuking dead block: " << *BB);
// Remove the instructions in the basic block from the worklist.
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
@ -1002,7 +1002,7 @@ void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) {
// Simple DCE.
if (isInstructionTriviallyDead(I)) {
DOUT << "Remove dead instruction '" << *I;
DEBUG(errs() << "Remove dead instruction '" << *I);
// Add uses to the worklist, which may be dead now.
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
@ -1091,7 +1091,7 @@ void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) {
// remove dead blocks.
break; // FIXME: Enable.
DOUT << "Folded branch: " << *BI;
DEBUG(errs() << "Folded branch: " << *BI);
BasicBlock *DeadSucc = BI->getSuccessor(CB->getZExtValue());
BasicBlock *LiveSucc = BI->getSuccessor(!CB->getZExtValue());
DeadSucc->removePredecessor(BI->getParent(), true);

7
llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
View File

@ -24,6 +24,7 @@
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetData.h"
#include <list>
using namespace llvm;
@ -454,10 +455,10 @@ bool MemCpyOpt::processStore(StoreInst *SI, BasicBlock::iterator& BBI) {
ConstantInt::get(Type::getInt32Ty(SI->getContext()), Range.Alignment)
};
Value *C = CallInst::Create(MemSetF, Ops, Ops+4, "", InsertPt);
DEBUG(cerr << "Replace stores:\n";
DEBUG(errs() << "Replace stores:\n";
for (unsigned i = 0, e = Range.TheStores.size(); i != e; ++i)
cerr << *Range.TheStores[i];
cerr << "With: " << *C); C=C;
errs() << *Range.TheStores[i];
errs() << "With: " << *C); C=C;
// Don't invalidate the iterator
BBI = BI;

38
llvm/lib/Transforms/Scalar/PredicateSimplifier.cpp
View File

@ -1385,8 +1385,8 @@ namespace {
}
bool makeEqual(Value *V1, Value *V2) {
DOUT << "makeEqual(" << *V1 << ", " << *V2 << ")\n";
DOUT << "context is ";
DEBUG(errs() << "makeEqual(" << *V1 << ", " << *V2 << ")\n");
DEBUG(errs() << "context is ");
DEBUG(if (TopInst)
errs() << "I: " << *TopInst << "\n";
else
@ -1491,8 +1491,8 @@ namespace {
ToNotify.push_back(I);
}
DOUT << "Simply removing " << *I2
<< ", replacing with " << *V1 << "\n";
DEBUG(errs() << "Simply removing " << *I2
<< ", replacing with " << *V1 << "\n");
I2->replaceAllUsesWith(V1);
// leave it dead; it'll get erased later.
++NumInstruction;
@ -1523,8 +1523,8 @@ namespace {
// If that killed the instruction, stop here.
if (I2 && isInstructionTriviallyDead(I2)) {
DOUT << "Killed all uses of " << *I2
<< ", replacing with " << *V1 << "\n";
DEBUG(errs() << "Killed all uses of " << *I2
<< ", replacing with " << *V1 << "\n");
continue;
}
@ -1730,10 +1730,12 @@ namespace {
/// add - adds a new property to the work queue
void add(Value *V1, Value *V2, ICmpInst::Predicate Pred,
Instruction *I = NULL) {
DOUT << "adding " << *V1 << " " << Pred << " " << *V2;
if (I) DOUT << " context: " << *I;
else DOUT << " default context (" << Top->getDFSNumIn() << ")";
DOUT << "\n";
DEBUG(errs() << "adding " << *V1 << " " << Pred << " " << *V2);
if (I)
DEBUG(errs() << " context: " << *I);
else
DEBUG(errs() << " default context (" << Top->getDFSNumIn() << ")");
DEBUG(errs() << "\n");
assert(V1->getType() == V2->getType() &&
"Can't relate two values with different types.");
@ -2132,9 +2134,9 @@ namespace {
/// solve - process the work queue
void solve() {
//DOUT << "WorkList entry, size: " << WorkList.size() << "\n";
//DEBUG(errs() << "WorkList entry, size: " << WorkList.size() << "\n");
while (!WorkList.empty()) {
//DOUT << "WorkList size: " << WorkList.size() << "\n";
//DEBUG(errs() << "WorkList size: " << WorkList.size() << "\n");
Operation &O = WorkList.front();
TopInst = O.ContextInst;
@ -2349,7 +2351,7 @@ namespace {
// Tries to simplify each Instruction and add new properties.
void visitInstruction(Instruction *I, DomTreeDFS::Node *DT) {
DOUT << "Considering instruction " << *I << "\n";
DEBUG(errs() << "Considering instruction " << *I << "\n");
DEBUG(VN->dump());
DEBUG(IG->dump());
DEBUG(VR->dump());
@ -2372,7 +2374,7 @@ namespace {
if (V != I) {
modified = true;
++NumInstruction;
DOUT << "Removing " << *I << ", replacing with " << *V << "\n";
DEBUG(errs() << "Removing " << *I << ", replacing with " << *V << "\n");
if (unsigned n = VN->valueNumber(I, DTDFS->getRootNode()))
if (VN->value(n) == I) IG->remove(n);
VN->remove(I);
@ -2389,18 +2391,18 @@ namespace {
if (V != Oper) {
modified = true;
++NumVarsReplaced;
DOUT << "Resolving " << *I;
DEBUG(errs() << "Resolving " << *I);
I->setOperand(i, V);
DOUT << " into " << *I;
DEBUG(errs() << " into " << *I);
}
}
#endif
std::string name = I->getParent()->getName();
DOUT << "push (%" << name << ")\n";
DEBUG(errs() << "push (%" << name << ")\n");
Forwards visit(this, DT);
visit.visit(*I);
DOUT << "pop (%" << name << ")\n";
DEBUG(errs() << "pop (%" << name << ")\n");
}
};

27
llvm/lib/Transforms/Scalar/Reassociate.cpp
View File

@ -34,6 +34,7 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ValueHandle.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/Statistic.h"
#include <algorithm>
@ -181,8 +182,8 @@ unsigned Reassociate::getRank(Value *V) {
(!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I)))
++Rank;
//DOUT << "Calculated Rank[" << V->getName() << "] = "
// << Rank << "\n";
//DEBUG(errs() << "Calculated Rank[" << V->getName() << "] = "
// << Rank << "\n");
return CachedRank = Rank;
}
@ -222,7 +223,7 @@ void Reassociate::LinearizeExpr(BinaryOperator *I) {
isReassociableOp(RHS, I->getOpcode()) &&
"Not an expression that needs linearization?");
DOUT << "Linear" << *LHS << '\n' << *RHS << '\n' << *I << '\n';
DEBUG(errs() << "Linear" << *LHS << '\n' << *RHS << '\n' << *I << '\n');
// Move the RHS instruction to live immediately before I, avoiding breaking
// dominator properties.
@ -235,7 +236,7 @@ void Reassociate::LinearizeExpr(BinaryOperator *I) {
++NumLinear;
MadeChange = true;
DOUT << "Linearized: " << *I << '\n';
DEBUG(errs() << "Linearized: " << *I << '\n');
// If D is part of this expression tree, tail recurse.
if (isReassociableOp(I->getOperand(1), I->getOpcode()))
@ -334,10 +335,10 @@ void Reassociate::RewriteExprTree(BinaryOperator *I,
if (I->getOperand(0) != Ops[i].Op ||
I->getOperand(1) != Ops[i+1].Op) {
Value *OldLHS = I->getOperand(0);
DOUT << "RA: " << *I << '\n';
DEBUG(errs() << "RA: " << *I << '\n');
I->setOperand(0, Ops[i].Op);
I->setOperand(1, Ops[i+1].Op);
DOUT << "TO: " << *I << '\n';
DEBUG(errs() << "TO: " << *I << '\n');
MadeChange = true;
++NumChanged;
@ -350,9 +351,9 @@ void Reassociate::RewriteExprTree(BinaryOperator *I,
assert(i+2 < Ops.size() && "Ops index out of range!");
if (I->getOperand(1) != Ops[i].Op) {
DOUT << "RA: " << *I << '\n';
DEBUG(errs() << "RA: " << *I << '\n');
I->setOperand(1, Ops[i].Op);
DOUT << "TO: " << *I << '\n';
DEBUG(errs() << "TO: " << *I << '\n');
MadeChange = true;
++NumChanged;
}
@ -450,7 +451,7 @@ static Instruction *BreakUpSubtract(LLVMContext &Context, Instruction *Sub,
Sub->replaceAllUsesWith(New);
Sub->eraseFromParent();
DOUT << "Negated: " << *New << '\n';
DEBUG(errs() << "Negated: " << *New << '\n');
return New;
}
@ -728,7 +729,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I,
// If any factor occurred more than one time, we can pull it out.
if (MaxOcc > 1) {
DOUT << "\nFACTORING [" << MaxOcc << "]: " << *MaxOccVal << "\n";
DEBUG(errs() << "\nFACTORING [" << MaxOcc << "]: " << *MaxOccVal << "\n");
// Create a new instruction that uses the MaxOccVal twice. If we don't do
// this, we could otherwise run into situations where removing a factor
@ -841,7 +842,7 @@ void Reassociate::ReassociateExpression(BinaryOperator *I) {
std::vector<ValueEntry> Ops;
LinearizeExprTree(I, Ops);
DOUT << "RAIn:\t"; DEBUG(PrintOps(I, Ops)); DOUT << "\n";
DEBUG(errs() << "RAIn:\t"; PrintOps(I, Ops); errs() << "\n");
// Now that we have linearized the tree to a list and have gathered all of
// the operands and their ranks, sort the operands by their rank. Use a
@ -856,7 +857,7 @@ void Reassociate::ReassociateExpression(BinaryOperator *I) {
if (Value *V = OptimizeExpression(I, Ops)) {
// This expression tree simplified to something that isn't a tree,
// eliminate it.
DOUT << "Reassoc to scalar: " << *V << "\n";
DEBUG(errs() << "Reassoc to scalar: " << *V << "\n");
I->replaceAllUsesWith(V);
RemoveDeadBinaryOp(I);
return;
@ -874,7 +875,7 @@ void Reassociate::ReassociateExpression(BinaryOperator *I) {
Ops.pop_back();
}
DOUT << "RAOut:\t"; DEBUG(PrintOps(I, Ops)); DOUT << "\n";
DEBUG(errs() << "RAOut:\t"; PrintOps(I, Ops); errs() << "\n");
if (Ops.size() == 1) {
// This expression tree simplified to something that isn't a tree,

4
llvm/lib/Transforms/Scalar/SCCP.cpp
View File

@ -416,7 +416,7 @@ private:
void visitInstruction(Instruction &I) {
// If a new instruction is added to LLVM that we don't handle...
cerr << "SCCP: Don't know how to handle: " << I;
errs() << "SCCP: Don't know how to handle: " << I;
markOverdefined(&I); // Just in case
}
};
@ -516,7 +516,7 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) {
return false;
} else {
#ifndef NDEBUG
cerr << "Unknown terminator instruction: " << *TI << '\n';
errs() << "Unknown terminator instruction: " << *TI << '\n';
#endif
llvm_unreachable(0);
}

24
llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp
View File

@ -39,6 +39,7 @@
#include "llvm/Support/IRBuilder.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
@ -244,8 +245,8 @@ bool SROA::performScalarRepl(Function &F) {
// constructs like "void foo() { int A[] = {1,2,3,4,5,6,7,8,9...}; }" if 'A'
// is only subsequently read.
if (Instruction *TheCopy = isOnlyCopiedFromConstantGlobal(AI)) {
DOUT << "Found alloca equal to global: " << *AI;
DOUT << " memcpy = " << *TheCopy;
DEBUG(errs() << "Found alloca equal to global: " << *AI);
DEBUG(errs() << " memcpy = " << *TheCopy);
Constant *TheSrc = cast<Constant>(TheCopy->getOperand(2));
AI->replaceAllUsesWith(ConstantExpr::getBitCast(TheSrc, AI->getType()));
TheCopy->eraseFromParent(); // Don't mutate the global.
@ -306,13 +307,14 @@ bool SROA::performScalarRepl(Function &F) {
// we just get a lot of insert/extracts. If at least one vector is
// involved, then we probably really do have a union of vector/array.
if (VectorTy && isa<VectorType>(VectorTy) && HadAVector) {
DOUT << "CONVERT TO VECTOR: " << *AI << " TYPE = " << *VectorTy <<"\n";
DEBUG(errs() << "CONVERT TO VECTOR: " << *AI << " TYPE = "
<< *VectorTy << '\n');
// Create and insert the vector alloca.
NewAI = new AllocaInst(VectorTy, 0, "", AI->getParent()->begin());
ConvertUsesToScalar(AI, NewAI, 0);
} else {
DOUT << "CONVERT TO SCALAR INTEGER: " << *AI << "\n";
DEBUG(errs() << "CONVERT TO SCALAR INTEGER: " << *AI << "\n");
// Create and insert the integer alloca.
const Type *NewTy = IntegerType::get(AI->getContext(), AllocaSize*8);
@ -336,7 +338,7 @@ bool SROA::performScalarRepl(Function &F) {
/// predicate, do SROA now.
void SROA::DoScalarReplacement(AllocationInst *AI,
std::vector<AllocationInst*> &WorkList) {
DOUT << "Found inst to SROA: " << *AI;
DEBUG(errs() << "Found inst to SROA: " << *AI);
SmallVector<AllocaInst*, 32> ElementAllocas;
if (const StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) {
ElementAllocas.reserve(ST->getNumContainedTypes());
@ -487,7 +489,7 @@ void SROA::isSafeElementUse(Value *Ptr, bool isFirstElt, AllocationInst *AI,
if (Info.isUnsafe) return;
break;
}
DOUT << " Transformation preventing inst: " << *User;
DEBUG(errs() << " Transformation preventing inst: " << *User);
return MarkUnsafe(Info);
case Instruction::Call:
if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) {
@ -497,10 +499,10 @@ void SROA::isSafeElementUse(Value *Ptr, bool isFirstElt, AllocationInst *AI,
break;
}
}
DOUT << " Transformation preventing inst: " << *User;
DEBUG(errs() << " Transformation preventing inst: " << *User);
return MarkUnsafe(Info);
default:
DOUT << " Transformation preventing inst: " << *User;
DEBUG(errs() << " Transformation preventing inst: " << *User);
return MarkUnsafe(Info);
}
}
@ -925,7 +927,7 @@ void SROA::RewriteStoreUserOfWholeAlloca(StoreInst *SI,
IntegerType::get(SI->getContext(), AllocaSizeBits),
"", SI);
DOUT << "PROMOTING STORE TO WHOLE ALLOCA: " << *AI << *SI;
DEBUG(errs() << "PROMOTING STORE TO WHOLE ALLOCA: " << *AI << *SI);
// There are two forms here: AI could be an array or struct. Both cases
// have different ways to compute the element offset.
@ -1041,7 +1043,7 @@ void SROA::RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocationInst *AI,
TD->getTypeAllocSizeInBits(LI->getType()) != AllocaSizeBits)
return;
DOUT << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << *LI;
DEBUG(errs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << *LI);
// There are two forms here: AI could be an array or struct. Both cases
// have different ways to compute the element offset.
@ -1168,7 +1170,7 @@ int SROA::isSafeAllocaToScalarRepl(AllocationInst *AI) {
I != E; ++I) {
isSafeUseOfAllocation(cast<Instruction>(*I), AI, Info);
if (Info.isUnsafe) {
DOUT << "Cannot transform: " << *AI << " due to user: " << **I;
DEBUG(errs() << "Cannot transform: " << *AI << " due to user: " << **I);
return 0;
}
}

2
llvm/lib/Transforms/Scalar/TailDuplication.cpp
View File

@ -273,7 +273,7 @@ void TailDup::eliminateUnconditionalBranch(BranchInst *Branch) {
// Remove from DestBlock, move right before the term in DomBlock.
DestBlock->getInstList().remove(I);
DomBlock->getInstList().insert(DomBlock->getTerminator(), I);
DOUT << "Hoisted: " << *I;
DEBUG(errs() << "Hoisted: " << *I);
}
}
}

20
llvm/lib/Transforms/Utils/BasicInliner.cpp
View File

@ -13,7 +13,6 @@
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "basicinliner"
#include "llvm/Module.h"
#include "llvm/Function.h"
#include "llvm/Transforms/Utils/BasicInliner.h"
@ -21,6 +20,7 @@
#include "llvm/Support/CallSite.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SmallPtrSet.h"
#include <vector>
@ -89,7 +89,7 @@ void BasicInlinerImpl::inlineFunctions() {
}
}
DOUT << ": " << CallSites.size() << " call sites.\n";
DEBUG(errs() << ": " << CallSites.size() << " call sites.\n");
// Inline call sites.
bool Changed = false;
@ -109,22 +109,22 @@ void BasicInlinerImpl::inlineFunctions() {
}
InlineCost IC = CA.getInlineCost(CS, NeverInline);
if (IC.isAlways()) {
DOUT << " Inlining: cost=always"
<<", call: " << *CS.getInstruction();
DEBUG(errs() << " Inlining: cost=always"
<<", call: " << *CS.getInstruction());
} else if (IC.isNever()) {
DOUT << " NOT Inlining: cost=never"
<<", call: " << *CS.getInstruction();
DEBUG(errs() << " NOT Inlining: cost=never"
<<", call: " << *CS.getInstruction());
continue;
} else {
int Cost = IC.getValue();
if (Cost >= (int) BasicInlineThreshold) {
DOUT << " NOT Inlining: cost = " << Cost
<< ", call: " << *CS.getInstruction();
DEBUG(errs() << " NOT Inlining: cost = " << Cost
<< ", call: " << *CS.getInstruction());
continue;
} else {
DOUT << " Inlining: cost = " << Cost
<< ", call: " << *CS.getInstruction();
DEBUG(errs() << " Inlining: cost = " << Cost
<< ", call: " << *CS.getInstruction());
}
}

15
llvm/lib/Transforms/Utils/CodeExtractor.cpp
View File

@ -29,6 +29,7 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/StringExtras.h"
#include <algorithm>
#include <set>
@ -236,8 +237,8 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
BasicBlock *newHeader,
Function *oldFunction,
Module *M) {
DOUT << "inputs: " << inputs.size() << "\n";
DOUT << "outputs: " << outputs.size() << "\n";
DEBUG(errs() << "inputs: " << inputs.size() << "\n");
DEBUG(errs() << "outputs: " << outputs.size() << "\n");
// This function returns unsigned, outputs will go back by reference.
switch (NumExitBlocks) {
@ -253,25 +254,25 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
for (Values::const_iterator i = inputs.begin(),
e = inputs.end(); i != e; ++i) {
const Value *value = *i;
DOUT << "value used in func: " << *value << "\n";
DEBUG(errs() << "value used in func: " << *value << "\n");
paramTy.push_back(value->getType());
}
// Add the types of the output values to the function's argument list.
for (Values::const_iterator I = outputs.begin(), E = outputs.end();
I != E; ++I) {
DOUT << "instr used in func: " << **I << "\n";
DEBUG(errs() << "instr used in func: " << **I << "\n");
if (AggregateArgs)
paramTy.push_back((*I)->getType());
else
paramTy.push_back(PointerType::getUnqual((*I)->getType()));
}
DOUT << "Function type: " << *RetTy << " f(";
DEBUG(errs() << "Function type: " << *RetTy << " f(");
for (std::vector<const Type*>::iterator i = paramTy.begin(),
e = paramTy.end(); i != e; ++i)
DOUT << **i << ", ";
DOUT << ")\n";
DEBUG(errs() << **i << ", ");
DEBUG(errs() << ")\n");
if (AggregateArgs && (inputs.size() + outputs.size() > 0)) {
PointerType *StructPtr =

41
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
View File

@ -185,7 +185,7 @@ static bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB,
}
}
DOUT << "Killing Trivial BB: \n" << *BB;
DEBUG(errs() << "Killing Trivial BB: \n" << *BB);
if (isa<PHINode>(Succ->begin())) {
// If there is more than one pred of succ, and there are PHI nodes in
@ -618,8 +618,8 @@ static bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
// Remove PHI node entries for the dead edge.
ThisCases[0].second->removePredecessor(TI->getParent());
DOUT << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n";
DEBUG(errs() << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n");
EraseTerminatorInstAndDCECond(TI);
return true;
@ -631,8 +631,8 @@ static bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
DeadCases.insert(PredCases[i].first);
DOUT << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI;
DEBUG(errs() << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI);
for (unsigned i = SI->getNumCases()-1; i != 0; --i)
if (DeadCases.count(SI->getCaseValue(i))) {
@ -640,7 +640,7 @@ static bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
SI->removeCase(i);
}
DOUT << "Leaving: " << *TI << "\n";
DEBUG(errs() << "Leaving: " << *TI << "\n");
return true;
}
}
@ -682,8 +682,8 @@ static bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
// Insert the new branch.
Instruction *NI = BranchInst::Create(TheRealDest, TI);
DOUT << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n";
DEBUG(errs() << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n");
EraseTerminatorInstAndDCECond(TI);
return true;
@ -1451,9 +1451,9 @@ static bool SimplifyCondBranchToTwoReturns(BranchInst *BI) {
ReturnInst::Create(BI->getContext(), BI) :
ReturnInst::Create(BI->getContext(), TrueValue, BI);
DOUT << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:"
<< "\n " << *BI << "NewRet = " << *RI
<< "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc;
DEBUG(errs() << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:"
<< "\n " << *BI << "NewRet = " << *RI
<< "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc);
EraseTerminatorInstAndDCECond(BI);
@ -1533,7 +1533,7 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI) {
else
continue;
DOUT << "FOLDING BRANCH TO COMMON DEST:\n" << *PBI << *BB;
DEBUG(errs() << "FOLDING BRANCH TO COMMON DEST:\n" << *PBI << *BB);
// If we need to invert the condition in the pred block to match, do so now.
if (InvertPredCond) {
@ -1667,8 +1667,8 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) {
// Finally, if everything is ok, fold the branches to logical ops.
BasicBlock *OtherDest = BI->getSuccessor(BIOp ^ 1);
DOUT << "FOLDING BRs:" << *PBI->getParent()
<< "AND: " << *BI->getParent();
DEBUG(errs() << "FOLDING BRs:" << *PBI->getParent()
<< "AND: " << *BI->getParent());
// If OtherDest *is* BB, then BB is a basic block with a single conditional
@ -1687,7 +1687,7 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) {
OtherDest = InfLoopBlock;
}
DOUT << *PBI->getParent()->getParent();
DEBUG(errs() << *PBI->getParent()->getParent());
// BI may have other predecessors. Because of this, we leave
// it alone, but modify PBI.
@ -1737,9 +1737,8 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) {
}
}
DOUT << "INTO: " << *PBI->getParent();
DOUT << *PBI->getParent()->getParent();
DEBUG(errs() << "INTO: " << *PBI->getParent());
DEBUG(errs() << *PBI->getParent()->getParent());
// This basic block is probably dead. We know it has at least
// one fewer predecessor.
@ -1766,7 +1765,7 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
// Remove basic blocks that have no predecessors... or that just have themself
// as a predecessor. These are unreachable.
if (pred_begin(BB) == pred_end(BB) || BB->getSinglePredecessor() == BB) {
DOUT << "Removing BB: \n" << *BB;
DEBUG(errs() << "Removing BB: \n" << *BB);
DeleteDeadBlock(BB);
return true;
}
@ -1806,8 +1805,8 @@ bool llvm::SimplifyCFG(BasicBlock *BB) {
if (!UncondBranchPreds.empty()) {
while (!UncondBranchPreds.empty()) {
BasicBlock *Pred = UncondBranchPreds.pop_back_val();
DOUT << "FOLDING: " << *BB
<< "INTO UNCOND BRANCH PRED: " << *Pred;
DEBUG(errs() << "FOLDING: " << *BB
<< "INTO UNCOND BRANCH PRED: " << *Pred);
Instruction *UncondBranch = Pred->getTerminator();
// Clone the return and add it to the end of the predecessor.
Instruction *NewRet = RI->clone(BB->getContext());

15
llvm/lib/Transforms/Utils/UnrollLoop.cpp
View File

@ -63,7 +63,7 @@ static BasicBlock *FoldBlockIntoPredecessor(BasicBlock *BB, LoopInfo* LI) {
if (OnlyPred->getTerminator()->getNumSuccessors() != 1)
return 0;
DOUT << "Merging: " << *BB << "into: " << *OnlyPred;
DEBUG(errs() << "Merging: " << *BB << "into: " << *OnlyPred);
// Resolve any PHI nodes at the start of the block. They are all
// guaranteed to have exactly one entry if they exist, unless there are
@ -114,7 +114,8 @@ bool llvm::UnrollLoop(Loop *L, unsigned Count, LoopInfo* LI, LPPassManager* LPM)
if (!BI || BI->isUnconditional()) {
// The loop-rotate pass can be helpful to avoid this in many cases.
DOUT << " Can't unroll; loop not terminated by a conditional branch.\n";
DEBUG(errs() <<
" Can't unroll; loop not terminated by a conditional branch.\n");
return false;
}
@ -126,9 +127,9 @@ bool llvm::UnrollLoop(Loop *L, unsigned Count, LoopInfo* LI, LPPassManager* LPM)
TripMultiple = L->getSmallConstantTripMultiple();
if (TripCount != 0)
DOUT << " Trip Count = " << TripCount << "\n";
DEBUG(errs() << " Trip Count = " << TripCount << "\n");
if (TripMultiple != 1)
DOUT << " Trip Multiple = " << TripMultiple << "\n";
DEBUG(errs() << " Trip Multiple = " << TripMultiple << "\n");
// Effectively "DCE" unrolled iterations that are beyond the tripcount
// and will never be executed.
@ -160,11 +161,11 @@ bool llvm::UnrollLoop(Loop *L, unsigned Count, LoopInfo* LI, LPPassManager* LPM)
DEBUG(errs() << "UNROLLING loop %" << Header->getName()
<< " by " << Count);
if (TripMultiple == 0 || BreakoutTrip != TripMultiple) {
DOUT << " with a breakout at trip " << BreakoutTrip;
DEBUG(errs() << " with a breakout at trip " << BreakoutTrip);
} else if (TripMultiple != 1) {
DOUT << " with " << TripMultiple << " trips per branch";
DEBUG(errs() << " with " << TripMultiple << " trips per branch");
}
DOUT << "!\n";
DEBUG(errs() << "!\n");
}
std::vector<BasicBlock*> LoopBlocks = L->getBlocks();

3
llvm/lib/VMCore/AsmWriter.cpp
View File

@ -2085,10 +2085,11 @@ void Value::print(raw_ostream &ROS, AssemblyAnnotationWriter *AAW) const {
}
}
/*
void Value::print(std::ostream &O, AssemblyAnnotationWriter *AAW) const {
raw_os_ostream OS(O);
print(OS, AAW);
}
}*/
// Value::dump - allow easy printing of Values from the debugger.
void Value::dump() const { print(errs()); errs() << '\n'; }

2
llvm/tools/llvm-prof/llvm-prof.cpp
View File

@ -243,7 +243,7 @@ bool ProfileInfoPrinterPass::runOnModule(Module &M) {
// Print just a subset of the functions.
for (std::set<Function*>::iterator I = FunctionsToPrint.begin(),
E = FunctionsToPrint.end(); I != E; ++I)
(*I)->print(std::cout, &PA);
(*I)->print(outs(), &PA);
}
return false;