#include "llvm/ExecutionEngine/JIT.h"
#include "llvm/ExecutionEngine/Interpreter.h"
#include "llvm/ExecutionEngine/GenericValue.h"
-#include <iostream>
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
static Function *CreateFibFunction(Module *M) {
ExistingModuleProvider *MP = new ExistingModuleProvider(M);
ExecutionEngine *EE = ExecutionEngine::create(MP, false);
- std::cerr << "verifying... ";
+ errs() << "verifying... ";
if (verifyModule(*M)) {
- std::cerr << argv[0] << ": Error constructing function!\n";
+ errs() << argv[0] << ": Error constructing function!\n";
return 1;
}
- std::cerr << "OK\n";
- std::cerr << "We just constructed this LLVM module:\n\n---------\n" << *M;
- std::cerr << "---------\nstarting fibonacci(" << n << ") with JIT...\n";
+ errs() << "OK\n";
+ errs() << "We just constructed this LLVM module:\n\n---------\n" << *M;
+ errs() << "---------\nstarting fibonacci(" << n << ") with JIT...\n";
// Call the Fibonacci function with argument n:
std::vector<GenericValue> Args(1);
GenericValue GV = EE->runFunction(FibF, Args);
// import result of execution
- std::cout << "Result: " << GV.IntVal << "\n";
+ outs() << "Result: " << GV.IntVal << "\n";
return 0;
}
#include "llvm/ExecutionEngine/JIT.h"
#include "llvm/ExecutionEngine/Interpreter.h"
#include "llvm/ExecutionEngine/GenericValue.h"
-#include <iostream>
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
int main() {
ExistingModuleProvider* MP = new ExistingModuleProvider(M);
ExecutionEngine* EE = ExecutionEngine::create(MP, false);
- std::cout << "We just constructed this LLVM module:\n\n" << *M;
- std::cout << "\n\nRunning foo: " << std::flush;
+ outs() << "We just constructed this LLVM module:\n\n" << *M;
+ outs() << "\n\nRunning foo: ";
+ outs().flush();
// Call the `foo' function with no arguments:
std::vector<GenericValue> noargs;
GenericValue gv = EE->runFunction(FooF, noargs);
// Import result of execution:
- std::cout << "Result: " << gv.IntVal << "\n";
+ outs() << "Result: " << gv.IntVal << "\n";
return 0;
}
#include "llvm/Support/MathExtras.h"
#include <cassert>
#include <cstring>
-#include <iosfwd>
#include <string>
namespace llvm {
class Serializer;
class Deserializer;
class FoldingSetNodeID;
+ class raw_ostream;
template<typename T>
class SmallVectorImpl;
/// @}
/// @name Conversion Functions
/// @{
-
- void print(std::ostream &OS, bool isSigned) const;
+ void print(raw_ostream &OS, bool isSigned) const;
/// toString - Converts an APInt to a string and append it to Str. Str is
/// commonly a SmallString.
return V2 != V1;
}
-inline std::ostream &operator<<(std::ostream &OS, const APInt &I) {
+inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
I.print(OS, true);
return OS;
}
void Profile(FoldingSetNodeID& ID) const;
};
-inline std::ostream &operator<<(std::ostream &OS, const APSInt &I) {
+inline raw_ostream &operator<<(raw_ostream &OS, const APSInt &I) {
I.print(OS, I.isSigned());
return OS;
}
/// removeAttr - Remove a ParamAttr from an argument
void removeAttr(ParameterAttributes);
- virtual void print(std::ostream &OS) const;
- void print(std::ostream *OS) const {
- if (OS) print(*OS);
- }
-
/// classof - Methods for support type inquiry through isa, cast, and
/// dyn_cast:
///
#ifndef LLVM_ASSEMBLY_ASMANNOTATIONWRITER_H
#define LLVM_ASSEMBLY_ASMANNOTATIONWRITER_H
-#include <iosfwd>
-
namespace llvm {
class Function;
class BasicBlock;
class Instruction;
+class raw_ostream;
struct AssemblyAnnotationWriter {
// emitFunctionAnnot - This may be implemented to emit a string right before
// the start of a function.
- virtual void emitFunctionAnnot(const Function *F, std::ostream &OS) {}
+ virtual void emitFunctionAnnot(const Function *F, raw_ostream &OS) {}
// emitBasicBlockStartAnnot - This may be implemented to emit a string right
// after the basic block label, but before the first instruction in the block.
- virtual void emitBasicBlockStartAnnot(const BasicBlock *BB, std::ostream &OS){
+ virtual void emitBasicBlockStartAnnot(const BasicBlock *BB, raw_ostream &OS){
}
// emitBasicBlockEndAnnot - This may be implemented to emit a string right
// after the basic block.
- virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, std::ostream &OS){
+ virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, raw_ostream &OS){
}
// emitInstructionAnnot - This may be implemented to emit a string right
// before an instruction is emitted.
- virtual void emitInstructionAnnot(const Instruction *I, std::ostream &OS) {}
+ virtual void emitInstructionAnnot(const Instruction *I, raw_ostream &OS) {}
};
} // End llvm namespace
class Type;
class Module;
class Value;
+class raw_ostream;
// WriteTypeSymbolic - This attempts to write the specified type as a symbolic
// type, iff there is an entry in the Module's symbol table for the specified
// type or one of its component types. This is slower than a simple x << Type;
//
void WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
+void WriteTypeSymbolic(raw_ostream &, const Type *, const Module *M);
// WriteAsOperand - Write the name of the specified value out to the specified
// ostream. This can be useful when you just want to print int %reg126, not the
//
void WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
const Module *Context = 0);
+void WriteAsOperand(raw_ostream &, const Value *, bool PrintTy = true,
+ const Module *Context = 0);
} // End llvm namespace
const InstListType &getInstList() const { return InstList; }
InstListType &getInstList() { return InstList; }
- virtual void print(std::ostream &OS) const { print(OS, 0); }
- void print(std::ostream *OS) const { if (OS) print(*OS); }
- void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const BasicBlock *) { return true; }
static inline bool classof(const Value *V) {
class TargetMachine;
class Type;
class MachineConstantPool;
+class raw_ostream;
/// Abstract base class for all machine specific constantpool value subclasses.
///
/// print - Implement operator<<...
///
- virtual void print(std::ostream &O) const = 0;
+ void print(std::ostream &O) const;
void print(std::ostream *O) const { if (O) print(*O); }
+ virtual void print(raw_ostream &O) const = 0;
};
inline std::ostream &operator<<(std::ostream &OS,
V.print(OS);
return OS;
}
+
+inline raw_ostream &operator<<(raw_ostream &OS,
+ const MachineConstantPoolValue &V) {
+ V.print(OS);
+ return OS;
+}
+
/// This class is a data container for one entry in a MachineConstantPool.
/// It contains a pointer to the value and an offset from the start of
///
std::string getOperationName(const SelectionDAG *G = 0) const;
static const char* getIndexedModeName(ISD::MemIndexedMode AM);
+ void print(raw_ostream &OS, const SelectionDAG *G = 0) const;
void dump() const;
void dump(const SelectionDAG *G) const;
/// getNullValue.
virtual bool isNullValue() const = 0;
- virtual void print(std::ostream &O) const;
- void print(std::ostream *O) const { if (O) print(*O); }
-
/// canTrap - Return true if evaluation of this constant could trap. This is
/// true for things like constant expressions that could divide by zero.
bool canTrap() const;
size_t arg_size() const;
bool arg_empty() const;
- virtual void print(std::ostream &OS) const { print(OS, 0); }
- void print(std::ostream *OS) const { if (OS) print(*OS); }
- void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
/// viewCFG - This function is meant for use from the debugger. You can just
/// say 'call F->viewCFG()' and a ghostview window should pop up from the
/// program, displaying the CFG of the current function with the code for each
///
void eraseFromParent();
- virtual void print(std::ostream &OS) const;
- void print(std::ostream *OS) const { if (OS) print(*OS); }
-
/// set/getAliasee - These methods retrive and set alias target.
void setAliasee(Constant* GV);
const Constant* getAliasee() const {
/// replace constant initializers.
virtual void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U);
- virtual void print(std::ostream &OS) const;
- void print(std::ostream *OS) const { if (OS) print(*OS); }
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const GlobalVariable *) { return true; }
static inline bool classof(const Value *V) {
namespace llvm {
-struct AssemblyAnnotationWriter;
class PointerType;
class FunctionType;
class Module;
const std::string &getAsmString() const { return AsmString; }
const std::string &getConstraintString() const { return Constraints; }
- virtual void print(std::ostream &O) const { print(O, 0); }
- void print(std::ostream *O) const { if (O) print(*O); }
- void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
/// Verify - This static method can be used by the parser to check to see if
/// the specified constraint string is legal for the type. This returns true
/// if legal, false if not.
namespace llvm {
-struct AssemblyAnnotationWriter;
-
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
}
static bool isTrapping(unsigned op);
- virtual void print(std::ostream &OS) const { print(OS, 0); }
- void print(std::ostream *OS) const { if (OS) print(*OS); }
- void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
-
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Instruction *) { return true; }
static inline bool classof(const Value *V) {
/// @name Utility functions for printing and dumping Module objects
/// @{
public:
- /// Print the module to an output stream
- void print(std::ostream &OS) const { print(OS, 0); }
- void print(std::ostream *OS) const { if (OS) print(*OS); }
/// Print the module to an output stream with AssemblyAnnotationWriter.
+ void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const;
void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
- void print(std::ostream *OS, AssemblyAnnotationWriter *AAW) const {
- if (OS) print(*OS, AAW);
- }
- /// Dump the module to std::cerr (for debugging).
+
+ /// Dump the module to stderr (for debugging).
void dump() const;
/// This function causes all the subinstructions to "let go" of all references
/// that they are maintaining. This allows one to 'delete' a whole class at
/// An iostream inserter for modules.
inline std::ostream &operator<<(std::ostream &O, const Module &M) {
- M.print(O);
+ M.print(O, 0);
+ return O;
+}
+inline raw_ostream &operator<<(raw_ostream &O, const Module &M) {
+ M.print(O, 0);
return O;
}
+
inline ValueSymbolTable *
ilist_traits<Function>::getSymTab(Module *M) {
#include "llvm/ADT/APInt.h"
#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Streams.h"
-#include <iosfwd>
namespace llvm {
/// print - Print out the bounds to a stream...
///
- void print(std::ostream &OS) const;
- void print(std::ostream *OS) const { if (OS) print(*OS); }
+ void print(raw_ostream &OS) const;
/// dump - Allow printing from a debugger easily...
///
void dump() const;
};
-inline std::ostream &operator<<(std::ostream &OS, const ConstantRange &CR) {
+inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRange &CR) {
CR.print(OS);
return OS;
}
raw_ostream &operator<<(long N);
raw_ostream &operator<<(unsigned long long N);
raw_ostream &operator<<(long long N);
-
+ raw_ostream &operator<<(const void *P);
raw_ostream &operator<<(unsigned int N) {
return this->operator<<(static_cast<unsigned long>(N));
}
std::ostream &OS;
public:
raw_os_ostream(std::ostream &O) : OS(O) {}
-
+ ~raw_os_ostream();
+
/// flush_impl - The is the piece of the class that is implemented by
/// subclasses. This outputs the currently buffered data and resets the
/// buffer to empty.
#include "llvm/AbstractTypeUser.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Streams.h"
#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/iterator.h"
#include <string>
class PointerType;
class IntegerType;
class TypeMapBase;
+class raw_ostream;
/// This file contains the declaration of the Type class. For more "Type" type
/// stuff, look in DerivedTypes.h.
PATypeHandle *ContainedTys;
public:
+ void print(raw_ostream &O) const;
void print(std::ostream &O) const;
void print(std::ostream *O) const { if (O) print(*O); }
}
std::ostream &operator<<(std::ostream &OS, const Type &T);
+raw_ostream &operator<<(raw_ostream &OS, const Type &T);
} // End llvm namespace
class TypeSymbolTable;
template<typename ValueTy> class StringMapEntry;
typedef StringMapEntry<Value*> ValueName;
+class raw_ostream;
+class AssemblyAnnotationWriter;
//===----------------------------------------------------------------------===//
// Value Class
//
virtual void dump() const;
- /// print - Implement operator<< on Value...
+ /// print - Implement operator<< on Value.
///
- virtual void print(std::ostream &O) const = 0;
- void print(std::ostream *O) const { if (O) print(*O); }
+ 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.
///
V.print(OS);
return OS;
}
-
+inline raw_ostream &operator<<(raw_ostream &OS, const Value &V) {
+ V.print(OS);
+ return OS;
+}
+
void Use::init(Value *V, User *) {
Val = V;
if (V) V->addUse(*this);
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+//
+// FIXME: What does this do?
+//
+//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "loopvr"
#include "llvm/Analysis/LoopVR.h"
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/Debug.h"
-#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
char LoopVR::ID = 0;
-namespace {
static RegisterPass<LoopVR> X("loopvr", "Loop Value Ranges", true, true);
-}
/// getRange - determine the range for a particular SCEV within a given Loop
ConstantRange LoopVR::getRange(SCEVHandle S, Loop *L, ScalarEvolution &SE) {
bool LoopVR::runOnFunction(Function &F) { Map.clear(); return false; }
void LoopVR::print(std::ostream &os, const Module *) const {
+ raw_os_ostream OS(os);
for (std::map<Value *, ConstantRange *>::const_iterator I = Map.begin(),
E = Map.end(); I != E; ++I) {
- os << *I->first << ": ";
- I->second->print(os);
- os << "\n";
+ OS << *I->first << ": " << *I->second << '\n';
}
}
#include "llvm/Instructions.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/GraphWriter.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Config/config.h"
#include <fstream>
return Constants.size()-1;
}
+void MachineConstantPoolValue::print(std::ostream &o) const {
+ raw_os_ostream OS(o);
+ print(OS);
+}
void MachineConstantPool::print(std::ostream &OS) const {
for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/PseudoSourceValue.h"
-#include "llvm/Support/MathExtras.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLowering.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetMachine.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallSet.h"
void SDNode::dump() const { dump(0); }
void SDNode::dump(const SelectionDAG *G) const {
- cerr << (void*)this << ": ";
+ print(errs(), G);
+}
+
+void SDNode::print(raw_ostream &OS, const SelectionDAG *G) const {
+ OS << (void*)this << ": ";
for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
- if (i) cerr << ",";
+ if (i) OS << ",";
if (getValueType(i) == MVT::Other)
- cerr << "ch";
+ OS << "ch";
else
- cerr << getValueType(i).getMVTString();
+ OS << getValueType(i).getMVTString();
}
- cerr << " = " << getOperationName(G);
+ OS << " = " << getOperationName(G);
- cerr << " ";
+ OS << " ";
for (unsigned i = 0, e = getNumOperands(); i != e; ++i) {
- if (i) cerr << ", ";
- cerr << (void*)getOperand(i).Val;
+ if (i) OS << ", ";
+ OS << (void*)getOperand(i).Val;
if (unsigned RN = getOperand(i).ResNo)
- cerr << ":" << RN;
+ OS << ":" << RN;
}
if (!isTargetOpcode() && getOpcode() == ISD::VECTOR_SHUFFLE) {
SDNode *Mask = getOperand(2).Val;
- cerr << "<";
+ OS << "<";
for (unsigned i = 0, e = Mask->getNumOperands(); i != e; ++i) {
- if (i) cerr << ",";
+ if (i) OS << ",";
if (Mask->getOperand(i).getOpcode() == ISD::UNDEF)
- cerr << "u";
+ OS << "u";
else
- cerr << cast<ConstantSDNode>(Mask->getOperand(i))->getValue();
+ OS << cast<ConstantSDNode>(Mask->getOperand(i))->getValue();
}
- cerr << ">";
+ OS << ">";
}
if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(this)) {
- cerr << '<' << CSDN->getAPIntValue() << '>';
+ OS << '<' << CSDN->getAPIntValue() << '>';
} else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(this)) {
if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEsingle)
- cerr << '<' << CSDN->getValueAPF().convertToFloat() << '>';
+ OS << '<' << CSDN->getValueAPF().convertToFloat() << '>';
else if (&CSDN->getValueAPF().getSemantics()==&APFloat::IEEEdouble)
- cerr << '<' << CSDN->getValueAPF().convertToDouble() << '>';
+ OS << '<' << CSDN->getValueAPF().convertToDouble() << '>';
else {
CSDN->getValueAPF().convertToAPInt().dump();
- cerr << ")>";
+ OS << ")>";
}
} else if (const GlobalAddressSDNode *GADN =
dyn_cast<GlobalAddressSDNode>(this)) {
int offset = GADN->getOffset();
- cerr << '<';
- WriteAsOperand(*cerr.stream(), GADN->getGlobal());
- cerr << '>';
+ OS << '<';
+ WriteAsOperand(OS, GADN->getGlobal());
+ OS << '>';
if (offset > 0)
- cerr << " + " << offset;
+ OS << " + " << offset;
else
- cerr << " " << offset;
+ OS << " " << offset;
} else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
- cerr << "<" << FIDN->getIndex() << ">";
+ OS << "<" << FIDN->getIndex() << ">";
} else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(this)) {
- cerr << "<" << JTDN->getIndex() << ">";
+ OS << "<" << JTDN->getIndex() << ">";
} else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
int offset = CP->getOffset();
if (CP->isMachineConstantPoolEntry())
- cerr << "<" << *CP->getMachineCPVal() << ">";
+ OS << "<" << *CP->getMachineCPVal() << ">";
else
- cerr << "<" << *CP->getConstVal() << ">";
+ OS << "<" << *CP->getConstVal() << ">";
if (offset > 0)
- cerr << " + " << offset;
+ OS << " + " << offset;
else
- cerr << " " << offset;
+ OS << " " << offset;
} else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
- cerr << "<";
+ OS << "<";
const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
if (LBB)
- cerr << LBB->getName() << " ";
- cerr << (const void*)BBDN->getBasicBlock() << ">";
+ OS << LBB->getName() << " ";
+ OS << (const void*)BBDN->getBasicBlock() << ">";
} else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(this)) {
if (G && R->getReg() &&
TargetRegisterInfo::isPhysicalRegister(R->getReg())) {
- cerr << " " << G->getTarget().getRegisterInfo()->getName(R->getReg());
+ OS << " " << G->getTarget().getRegisterInfo()->getName(R->getReg());
} else {
- cerr << " #" << R->getReg();
+ OS << " #" << R->getReg();
}
} else if (const ExternalSymbolSDNode *ES =
dyn_cast<ExternalSymbolSDNode>(this)) {
- cerr << "'" << ES->getSymbol() << "'";
+ OS << "'" << ES->getSymbol() << "'";
} else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(this)) {
if (M->getValue())
- cerr << "<" << M->getValue() << ">";
+ OS << "<" << M->getValue() << ">";
else
- cerr << "<null>";
+ OS << "<null>";
} else if (const MemOperandSDNode *M = dyn_cast<MemOperandSDNode>(this)) {
if (M->MO.getValue())
- cerr << "<" << M->MO.getValue() << ":" << M->MO.getOffset() << ">";
+ OS << "<" << M->MO.getValue() << ":" << M->MO.getOffset() << ">";
else
- cerr << "<null:" << M->MO.getOffset() << ">";
+ OS << "<null:" << M->MO.getOffset() << ">";
} else if (const ARG_FLAGSSDNode *N = dyn_cast<ARG_FLAGSSDNode>(this)) {
- cerr << N->getArgFlags().getArgFlagsString();
+ OS << N->getArgFlags().getArgFlagsString();
} else if (const VTSDNode *N = dyn_cast<VTSDNode>(this)) {
- cerr << ":" << N->getVT().getMVTString();
+ OS << ":" << N->getVT().getMVTString();
}
else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(this)) {
const Value *SrcValue = LD->getSrcValue();
int SrcOffset = LD->getSrcValueOffset();
- cerr << " <";
+ OS << " <";
if (SrcValue)
- cerr << SrcValue;
+ OS << SrcValue;
else
- cerr << "null";
- cerr << ":" << SrcOffset << ">";
+ OS << "null";
+ OS << ":" << SrcOffset << ">";
bool doExt = true;
switch (LD->getExtensionType()) {
default: doExt = false; break;
- case ISD::EXTLOAD:
- cerr << " <anyext ";
- break;
- case ISD::SEXTLOAD:
- cerr << " <sext ";
- break;
- case ISD::ZEXTLOAD:
- cerr << " <zext ";
- break;
+ case ISD::EXTLOAD: OS << " <anyext "; break;
+ case ISD::SEXTLOAD: OS << " <sext "; break;
+ case ISD::ZEXTLOAD: OS << " <zext "; break;
}
if (doExt)
- cerr << LD->getMemoryVT().getMVTString() << ">";
+ OS << LD->getMemoryVT().getMVTString() << ">";
const char *AM = getIndexedModeName(LD->getAddressingMode());
if (*AM)
- cerr << " " << AM;
+ OS << " " << AM;
if (LD->isVolatile())
- cerr << " <volatile>";
- cerr << " alignment=" << LD->getAlignment();
+ OS << " <volatile>";
+ OS << " alignment=" << LD->getAlignment();
} else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(this)) {
const Value *SrcValue = ST->getSrcValue();
int SrcOffset = ST->getSrcValueOffset();
- cerr << " <";
+ OS << " <";
if (SrcValue)
- cerr << SrcValue;
+ OS << SrcValue;
else
- cerr << "null";
- cerr << ":" << SrcOffset << ">";
+ OS << "null";
+ OS << ":" << SrcOffset << ">";
if (ST->isTruncatingStore())
- cerr << " <trunc "
- << ST->getMemoryVT().getMVTString() << ">";
+ OS << " <trunc " << ST->getMemoryVT().getMVTString() << ">";
const char *AM = getIndexedModeName(ST->getAddressingMode());
if (*AM)
- cerr << " " << AM;
+ OS << " " << AM;
if (ST->isVolatile())
- cerr << " <volatile>";
- cerr << " alignment=" << ST->getAlignment();
+ OS << " <volatile>";
+ OS << " alignment=" << ST->getAlignment();
} else if (const AtomicSDNode* AT = dyn_cast<AtomicSDNode>(this)) {
const Value *SrcValue = AT->getSrcValue();
int SrcOffset = AT->getSrcValueOffset();
- cerr << " <";
+ OS << " <";
if (SrcValue)
- cerr << SrcValue;
+ OS << SrcValue;
else
- cerr << "null";
- cerr << ":" << SrcOffset << ">";
+ OS << "null";
+ OS << ":" << SrcOffset << ">";
if (AT->isVolatile())
- cerr << " <volatile>";
- cerr << " alignment=" << AT->getAlignment();
+ OS << " <volatile>";
+ OS << " alignment=" << AT->getAlignment();
}
}
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
#include <cmath>
#include <limits>
#include <cstring>
return result;
}
-void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned)
-{
+void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned) {
pVal = getClearedMemory(getNumWords());
pVal[0] = val;
if (isSigned && int64_t(val) < 0)
}
APInt::APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[])
- : BitWidth(numBits), VAL(0) {
+ : BitWidth(numBits), VAL(0) {
assert(BitWidth && "bitwidth too small");
assert(bigVal && "Null pointer detected!");
if (isSingleWord())
fprintf(stderr, "APInt(%db, %su %ss)", BitWidth, U.c_str(), S.c_str());
}
-void APInt::print(std::ostream &OS, bool isSigned) const {
+void APInt::print(raw_ostream &OS, bool isSigned) const {
SmallString<40> S;
this->toString(S, 10, isSigned);
OS << S.c_str();
}
-
// This implements a variety of operations on a representation of
// arbitrary precision, two's-complement, bignum integer values.
//===----------------------------------------------------------------------===//
#include "llvm/Support/ConstantRange.h"
-#include "llvm/Support/Streams.h"
-#include <ostream>
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
/// Initialize a full (the default) or empty set for the specified type.
/// print - Print out the bounds to a stream...
///
-void ConstantRange::print(std::ostream &OS) const {
+void ConstantRange::print(raw_ostream &OS) const {
OS << "[" << Lower << "," << Upper << ")";
}
/// dump - Allow printing from a debugger easily...
///
void ConstantRange::dump() const {
- print(cerr);
+ print(errs());
}
return this->operator<<(static_cast<unsigned long long>(N));
}
+raw_ostream &raw_ostream::operator<<(const void *P) {
+ // FIXME: This could be much faster if it matters.
+ return *this << format("%p", P);
+}
+
+
raw_ostream &raw_ostream::write(const char *Ptr, unsigned Size) {
if (OutBufCur+Size > OutBufEnd)
flush_impl();
// raw_os_ostream
//===----------------------------------------------------------------------===//
+raw_os_ostream::~raw_os_ostream() {
+ flush();
+}
+
/// flush_impl - The is the piece of the class that is implemented by
/// subclasses. This outputs the currently buffered data and resets the
/// buffer to empty.
#include "llvm/ADT/FoldingSet.h"
#include "llvm/GlobalValue.h"
#include "llvm/Type.h"
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
ARMConstantPoolValue::ARMConstantPoolValue(GlobalValue *gv, unsigned id,
ID.AddInteger(PCAdjust);
}
-void ARMConstantPoolValue::print(std::ostream &O) const {
+void ARMConstantPoolValue::print(raw_ostream &O) const {
if (GV)
O << GV->getName();
else
virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
- virtual void print(std::ostream &O) const;
+ virtual void print(raw_ostream &O) const;
};
}
#include "llvm/ADT/FoldingSet.h"
#include "llvm/GlobalValue.h"
#include "llvm/Type.h"
+#include "llvm/Support/raw_ostream.h"
using namespace llvm;
PIC16ConstantPoolValue::PIC16ConstantPoolValue(GlobalValue *gv, unsigned id,
ID.AddInteger(PCAdjust);
}
-void PIC16ConstantPoolValue::print(std::ostream &O) const {
+void PIC16ConstantPoolValue::print(raw_ostream &O) const {
if (GV)
O << GV->getName();
else
virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
- virtual void print(std::ostream &O) const;
+ virtual void print(raw_ostream &O) const;
};
}
void dump(std::ostream &os) const {
os << "{";
for (const_iterator I = begin(), E = end(); I != E; ++I) {
- os << I->second << " (" << I->first->getDFSNumIn() << "), ";
+ os << &I->second << " (" << I->first->getDFSNumIn() << "), ";
}
os << "}";
}
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
using namespace llvm;
DOUT << "RHS: " << RHS << "\n";
CaseRange& Pivot = *(Begin + Mid);
- DEBUG(cerr << "Pivot ==> "
- << cast<ConstantInt>(Pivot.Low)->getValue() << " -"
- << cast<ConstantInt>(Pivot.High)->getValue() << "\n");
+ DEBUG(errs() << "Pivot ==> "
+ << cast<ConstantInt>(Pivot.Low)->getValue() << " -"
+ << cast<ConstantInt>(Pivot.High)->getValue() << "\n";
+ errs().flush());
BasicBlock* LBranch = switchConvert(LHS.begin(), LHS.end(), Val,
OrigBlock, Default);
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cctype>
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
/// prefixed with % (if the string only contains simple characters) or is
/// surrounded with ""'s (if it has special chars in it). Print it out.
-static void PrintLLVMName(std::ostream &OS, const char *NameStr,
+static void PrintLLVMName(raw_ostream &OS, const char *NameStr,
unsigned NameLen, PrefixType Prefix) {
assert(NameStr && "Cannot get empty name!");
switch (Prefix) {
/// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
/// prefixed with % (if the string only contains simple characters) or is
/// surrounded with ""'s (if it has special chars in it). Print it out.
-static void PrintLLVMName(std::ostream &OS, const Value *V) {
+static void PrintLLVMName(raw_ostream &OS, const Value *V) {
PrintLLVMName(OS, V->getNameStart(), V->getNameLen(),
isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
}
// AsmWriter Implementation
//===----------------------------------------------------------------------===//
-static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
+static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
std::map<const Type *, std::string> &TypeTable,
SlotTracker *Machine);
/// printTypeInt - The internal guts of printing out a type that has a
/// potentially named portion.
///
-static void printTypeInt(std::ostream &Out, const Type *Ty,
+static void printTypeInt(raw_ostream &Out, const Type *Ty,
std::map<const Type *, std::string> &TypeNames) {
// Primitive types always print out their description, regardless of whether
// they have been named or not.
///
void llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
const Module *M) {
+ raw_os_ostream RO(Out);
+ WriteTypeSymbolic(RO, Ty, M);
+}
+
+void llvm::WriteTypeSymbolic(raw_ostream &Out, const Type *Ty, const Module *M){
Out << ' ';
// If they want us to print out a type, but there is no context, we can't
// PrintEscapedString - Print each character of the specified string, escaping
// it if it is not printable or if it is an escape char.
-static void PrintEscapedString(const std::string &Str, std::ostream &Out) {
+static void PrintEscapedString(const std::string &Str, raw_ostream &Out) {
for (unsigned i = 0, e = Str.size(); i != e; ++i) {
unsigned char C = Str[i];
if (isprint(C) && C != '"' && C != '\\') {
return pred;
}
-static void WriteConstantInt(std::ostream &Out, const Constant *CV,
+static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
std::map<const Type *, std::string> &TypeTable,
SlotTracker *Machine) {
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
/// ostream. This can be useful when you just want to print int %reg126, not
/// the whole instruction that generated it.
///
-static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
+static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
std::map<const Type*, std::string> &TypeTable,
SlotTracker *Machine) {
Out << ' ';
///
void llvm::WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
const Module *Context) {
+ raw_os_ostream OS(Out);
+ WriteAsOperand(OS, V, PrintType, Context);
+}
+
+void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, bool PrintType,
+ const Module *Context) {
std::map<const Type *, std::string> TypeNames;
if (Context == 0) Context = getModuleFromVal(V);
namespace {
class AssemblyWriter {
- std::ostream &Out;
+ raw_ostream &Out;
SlotTracker &Machine;
const Module *TheModule;
std::map<const Type *, std::string> TypeNames;
AssemblyAnnotationWriter *AnnotationWriter;
public:
- inline AssemblyWriter(std::ostream &o, SlotTracker &Mac, const Module *M,
+ inline AssemblyWriter(raw_ostream &o, SlotTracker &Mac, const Module *M,
AssemblyAnnotationWriter *AAW)
: Out(o), Machine(Mac), TheModule(M), AnnotationWriter(AAW) {
fillTypeNameTable(M, TypeNames);
}
- void write(const Module *M) { printModule(M); }
- void write(const GlobalVariable *G) { printGlobal(G); }
- void write(const GlobalAlias *G) { printAlias(G); }
- void write(const Function *F) { printFunction(F); }
+ void write(const Module *M) { printModule(M); }
+
+ void write(const GlobalValue *G) {
+ if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(G))
+ printGlobal(GV);
+ else if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(G))
+ printAlias(GA);
+ else if (const Function *F = dyn_cast<Function>(G))
+ printFunction(F);
+ else
+ assert(0 && "Unknown global");
+ }
+
void write(const BasicBlock *BB) { printBasicBlock(BB); }
void write(const Instruction *I) { printInstruction(*I); }
void write(const Type *Ty) { printType(Ty); }
printFunction(I);
}
-static void PrintLinkage(GlobalValue::LinkageTypes LT, std::ostream &Out) {
+static void PrintLinkage(GlobalValue::LinkageTypes LT, raw_ostream &Out) {
switch (LT) {
case GlobalValue::InternalLinkage: Out << "internal "; break;
case GlobalValue::LinkOnceLinkage: Out << "linkonce "; break;
static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
- std::ostream &Out) {
+ raw_ostream &Out) {
switch (Vis) {
default: assert(0 && "Invalid visibility style!");
case GlobalValue::DefaultVisibility: break;
//===----------------------------------------------------------------------===//
void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
- SlotTracker SlotTable(this);
- AssemblyWriter W(o, SlotTable, this, AAW);
- W.write(this);
-}
-
-void GlobalVariable::print(std::ostream &o) const {
- SlotTracker SlotTable(getParent());
- AssemblyWriter W(o, SlotTable, getParent(), 0);
- W.write(this);
-}
-
-void GlobalAlias::print(std::ostream &o) const {
- SlotTracker SlotTable(getParent());
- AssemblyWriter W(o, SlotTable, getParent(), 0);
- W.write(this);
-}
-
-void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
- SlotTracker SlotTable(getParent());
- AssemblyWriter W(o, SlotTable, getParent(), AAW);
-
- W.write(this);
+ raw_os_ostream OS(o);
+ print(OS, AAW);
}
-
-void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
- WriteAsOperand(o, this, true, 0);
-}
-
-void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
- SlotTracker SlotTable(getParent());
- AssemblyWriter W(o, SlotTable,
- getParent() ? getParent()->getParent() : 0, AAW);
- W.write(this);
-}
-
-void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
- const Function *F = getParent() ? getParent()->getParent() : 0;
- SlotTracker SlotTable(F);
- AssemblyWriter W(o, SlotTable, F ? F->getParent() : 0, AAW);
-
+void Module::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
+ SlotTracker SlotTable(this);
+ AssemblyWriter W(OS, SlotTable, this, AAW);
W.write(this);
}
-void Constant::print(std::ostream &o) const {
- if (this == 0) { o << "<null> constant value\n"; return; }
-
- o << ' ' << getType()->getDescription() << ' ';
-
- std::map<const Type *, std::string> TypeTable;
- WriteConstantInt(o, this, TypeTable, 0);
+void Type::print(std::ostream &o) const {
+ raw_os_ostream OS(o);
+ print(OS);
}
-void Type::print(std::ostream &o) const {
+void Type::print(raw_ostream &o) const {
if (this == 0)
o << "<null Type>";
else
o << getDescription();
}
-void Argument::print(std::ostream &o) const {
- WriteAsOperand(o, this, true, getParent() ? getParent()->getParent() : 0);
+void Value::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
+ if (this == 0) {
+ OS << "printing a <null> value\n";
+ return;
+ }
+
+ if (const Instruction *I = dyn_cast<Instruction>(this)) {
+ const Function *F = I->getParent() ? I->getParent()->getParent() : 0;
+ SlotTracker SlotTable(F);
+ AssemblyWriter W(OS, SlotTable, F ? F->getParent() : 0, AAW);
+ W.write(I);
+ } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
+ SlotTracker SlotTable(BB->getParent());
+ AssemblyWriter W(OS, SlotTable,
+ BB->getParent() ? BB->getParent()->getParent() : 0, AAW);
+ W.write(BB);
+ } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
+ SlotTracker SlotTable(GV->getParent());
+ AssemblyWriter W(OS, SlotTable, GV->getParent(), 0);
+ W.write(GV);
+ } else if (const Constant *C = dyn_cast<Constant>(this)) {
+ OS << ' ' << C->getType()->getDescription() << ' ';
+ std::map<const Type *, std::string> TypeTable;
+ WriteConstantInt(OS, C, TypeTable, 0);
+ } else if (const Argument *A = dyn_cast<Argument>(this)) {
+ WriteAsOperand(OS, this, true,
+ A->getParent() ? A->getParent()->getParent() : 0);
+ } else if (isa<InlineAsm>(this)) {
+ WriteAsOperand(OS, this, true, 0);
+ } else {
+ assert(0 && "Unknown value to print out!");
+ }
+}
+
+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.
// Located here because so much of the needed functionality is here.
-void Value::dump() const { print(*cerr.stream()); cerr << '\n'; }
+void Value::dump() const { print(errs()); errs() << '\n'; }
// Type::dump - allow easy printing of Values from the debugger.
// Located here because so much of the needed functionality is here.
-void Type::dump() const { print(*cerr.stream()); cerr << '\n'; }
+void Type::dump() const { print(errs()); errs() << '\n'; }
+
+// Module::dump() - Allow printing from debugger
+void Module::dump() const { print(errs(), 0); }
+
delete TypeSymTab;
}
-// Module::dump() - Allow printing from debugger
-void Module::dump() const {
- print(*cerr.stream());
-}
-
/// Target endian information...
Module::Endianness Module::getEndianness() const {
std::string temp = DataLayout;
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Signals.h"
#include <algorithm>
#include <iostream>
std::map<ProfileInfoLoader::Edge, unsigned> &EF)
: FuncFreqs(FF), BlockFreqs(BF), EdgeFreqs(EF) {}
- virtual void emitFunctionAnnot(const Function *F, std::ostream &OS) {
+ virtual void emitFunctionAnnot(const Function *F, raw_ostream &OS) {
OS << ";;; %" << F->getName() << " called " << FuncFreqs[F]
<< " times.\n;;;\n";
}
virtual void emitBasicBlockStartAnnot(const BasicBlock *BB,
- std::ostream &OS) {
+ raw_ostream &OS) {
if (BlockFreqs.empty()) return;
if (unsigned Count = BlockFreqs[BB])
OS << "\t;;; Basic block executed " << Count << " times.\n";
OS << "\t;;; Never executed!\n";
}
- virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, std::ostream &OS){
+ virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, raw_ostream &OS) {
if (EdgeFreqs.empty()) return;
// Figure out how many times each successor executed.
if (FunctionsToPrint.empty() || PrintAllCode)
M->print(std::cout, &PA);
else
- // Print just a subset of the functions...
+ // 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);
projects / oota-llvm.git / commitdiff