6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-06 04:29:18 +00:00
Code Issues Projects Releases Wiki Activity

Switch the asmprinter (.ll) and all the stuff it requires over to

Browse Source 
use raw_ostream instead of std::ostream.  Among other goodness,
this speeds up llvm-dis of kc++ with a release build from 0.85s
to 0.49s (88% faster).

Other interesting changes:
 1) This makes Value::print be non-virtual.
 2) AP[S]Int and ConstantRange can no longer print to ostream directly, 
    use raw_ostream instead.
 3) This fixes a bug in raw_os_ostream where it didn't flush itself 
    when destroyed.
 4) This adds a new SDNode::print method, instead of only allowing "dump".


A lot of APIs have both std::ostream and raw_ostream versions, it would
be useful to go through and systematically anihilate the std::ostream 
versions.

This passes dejagnu, but there may be minor fallout, plz let me know if
so and I'll fix it.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@55263 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-08-23 22:23:09 +00:00
parent ef5dc366e7
commit 944fac71e0
36 changed files with 270 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
examples/Fibonacci/fibonacci.cpp
View File

@ -32,7 +32,7 @@
#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) {
@ -100,15 +100,15 @@ int main(int argc, char **argv) {
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);
@ -116,6 +116,6 @@ int main(int argc, char **argv) {
GenericValue GV = EE->runFunction(FibF, Args);
// import result of execution
std::cout << "Result: " << GV.IntVal << "\n";
outs() << "Result: " << GV.IntVal << "\n";
return 0;
}

9
examples/HowToUseJIT/HowToUseJIT.cpp
View File

@ -42,7 +42,7 @@
#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() {
@ -99,14 +99,15 @@ 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;
}

7
include/llvm/ADT/APInt.h
View File

@ -19,13 +19,13 @@
#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;
@ -1115,8 +1115,7 @@ public:
/// @}
/// @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.
@ -1385,7 +1384,7 @@ inline bool operator!=(uint64_t V1, const APInt& V2) {
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;
}

2
include/llvm/ADT/APSInt.h
View File

@ -239,7 +239,7 @@ public:
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;
}

5
include/llvm/Argument.h
View File

@ -65,11 +65,6 @@ public:
/// 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:
///

11
include/llvm/Assembly/AsmAnnotationWriter.h
View File

@ -17,13 +17,12 @@
#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 {
@ -31,21 +30,21 @@ 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

4
include/llvm/Assembly/Writer.h
View File

@ -24,12 +24,14 @@ namespace llvm {
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
@ -39,6 +41,8 @@ void WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
//
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

4
include/llvm/BasicBlock.h
View File

@ -157,10 +157,6 @@ public:
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) {

11
include/llvm/CodeGen/MachineConstantPool.h
View File

@ -29,6 +29,7 @@ class TargetData;
class TargetMachine;
class Type;
class MachineConstantPool;
class raw_ostream;
/// Abstract base class for all machine specific constantpool value subclasses.
///
@ -50,8 +51,9 @@ public:
/// 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,
@ -59,6 +61,13 @@ 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

1
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -1260,6 +1260,7 @@ public:
///
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;

3
include/llvm/Constant.h
View File

@ -58,9 +58,6 @@ public:
/// 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;

4
include/llvm/Function.h
View File

@ -301,10 +301,6 @@ public:
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

3
include/llvm/GlobalAlias.h
View File

@ -62,9 +62,6 @@ public:
///
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 {

3
include/llvm/GlobalVariable.h
View File

@ -133,9 +133,6 @@ public:
/// 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) {

5
include/llvm/InlineAsm.h
View File

@ -21,7 +21,6 @@
namespace llvm {
struct AssemblyAnnotationWriter;
class PointerType;
class FunctionType;
class Module;
@ -58,10 +57,6 @@ public:
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.

6
include/llvm/Instruction.h
View File

@ -20,8 +20,6 @@
namespace llvm {
struct AssemblyAnnotationWriter;
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
@ -180,10 +178,6 @@ public:
}
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) {

17
include/llvm/Module.h
View File

@ -350,15 +350,11 @@ public:
/// @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
@ -385,9 +381,14 @@ public:
/// 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) {

7
include/llvm/Support/ConstantRange.h
View File

@ -32,8 +32,6 @@
#include "llvm/ADT/APInt.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Streams.h"
#include <iosfwd>
namespace llvm {
@ -180,15 +178,14 @@ class ConstantRange {
/// 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;
}

5
include/llvm/Support/raw_ostream.h
View File

@ -96,7 +96,7 @@ public:
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));
}
@ -201,7 +201,8 @@ class raw_os_ostream : public raw_ostream {
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.

4
include/llvm/Type.h
View File

@ -14,7 +14,6 @@
#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>
@ -26,6 +25,7 @@ class DerivedType;
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.
@ -156,6 +156,7 @@ protected:
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); }
@ -450,6 +451,7 @@ template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
}
std::ostream &operator<<(std::ostream &OS, const Type &T);
raw_ostream &operator<<(raw_ostream &OS, const Type &T);
} // End llvm namespace

14
include/llvm/Value.h
View File

@ -35,6 +35,8 @@ class ValueSymbolTable;
class TypeSymbolTable;
template<typename ValueTy> class StringMapEntry;
typedef StringMapEntry<Value*> ValueName;
class raw_ostream;
class AssemblyAnnotationWriter;
//===----------------------------------------------------------------------===//
// Value Class
@ -76,10 +78,10 @@ public:
//
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.
///
@ -237,7 +239,11 @@ 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;
}
void Use::init(Value *V, User *) {
Val = V;
if (V) V->addUse(*this);

13
lib/Analysis/LoopVR.cpp
View File

@ -6,6 +6,10 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// FIXME: What does this do?
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "loopvr"
#include "llvm/Analysis/LoopVR.h"
@ -15,13 +19,11 @@
#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) {
@ -220,11 +222,10 @@ ConstantRange LoopVR::getRange(SCEVHandle S, SCEVHandle T, 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';
}
}

5
lib/CodeGen/MachineFunction.cpp
View File

@ -28,6 +28,7 @@
#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>
@ -525,6 +526,10 @@ unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V,
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) {

148
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -24,12 +24,13 @@
#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"
@ -4980,169 +4981,166 @@ std::string ISD::ArgFlagsTy::getArgFlagsString() {
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 {
cerr << "<APFloat(";
OS << "<APFloat(";
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();
}
}

9
lib/Support/APInt.cpp
View File

@ -18,6 +18,7 @@
#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>
@ -41,8 +42,7 @@ inline static uint64_t* getMemory(uint32_t numWords) {
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)
@ -51,7 +51,7 @@ void APInt::initSlowCase(uint32_t numBits, uint64_t val, bool isSigned)
}
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())
@ -1995,13 +1995,12 @@ void APInt::dump() const {
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.

7
lib/Support/ConstantRange.cpp
View File

@ -22,8 +22,7 @@
//===----------------------------------------------------------------------===//
#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.
@ -462,12 +461,12 @@ ConstantRange ConstantRange::truncate(uint32_t DstTySize) const {
/// 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());
}

10
lib/Support/raw_ostream.cpp
View File

@ -99,6 +99,12 @@ raw_ostream &raw_ostream::operator<<(long long N) {
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();
@ -250,6 +256,10 @@ raw_ostream &llvm::errs() {
// 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.

3
lib/Target/ARM/ARMConstantPoolValue.cpp
View File

@ -15,6 +15,7 @@
#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,
@ -72,7 +73,7 @@ ARMConstantPoolValue::AddSelectionDAGCSEId(FoldingSetNodeID &ID) {
ID.AddInteger(PCAdjust);
}
void ARMConstantPoolValue::print(std::ostream &O) const {
void ARMConstantPoolValue::print(raw_ostream &O) const {
if (GV)
O << GV->getName();
else

2
lib/Target/ARM/ARMConstantPoolValue.h
View File

@ -69,7 +69,7 @@ public:
virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
virtual void print(std::ostream &O) const;
virtual void print(raw_ostream &O) const;
};
}

3
lib/Target/PIC16/PIC16ConstantPoolValue.cpp
View File

@ -15,6 +15,7 @@
#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,
@ -70,7 +71,7 @@ PIC16ConstantPoolValue::AddSelectionDAGCSEId(FoldingSetNodeID &ID) {
ID.AddInteger(PCAdjust);
}
void PIC16ConstantPoolValue::print(std::ostream &O) const {
void PIC16ConstantPoolValue::print(raw_ostream &O) const {
if (GV)
O << GV->getName();
else

2
lib/Target/PIC16/PIC16ConstantPoolValue.h
View File

@ -69,7 +69,7 @@ public:
virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
virtual void print(std::ostream &O) const;
virtual void print(raw_ostream &O) const;
};
}

2
lib/Transforms/Scalar/PredicateSimplifier.cpp
View File

@ -922,7 +922,7 @@ namespace {
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 << "}";
}

8
lib/Transforms/Utils/LowerSwitch.cpp
View File

@ -22,6 +22,7 @@
#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;
@ -144,9 +145,10 @@ BasicBlock* LowerSwitch::switchConvert(CaseItr Begin, CaseItr End,
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);

156
lib/VMCore/AsmWriter.cpp
View File

@ -31,7 +31,6 @@
#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>
@ -126,7 +125,7 @@ enum PrefixType {
/// 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) {
@ -184,7 +183,7 @@ static void PrintLLVMName(std::ostream &OS, const char *NameStr,
/// 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);
}
@ -439,7 +438,7 @@ void SlotTracker::CreateFunctionSlot(const Value *V) {
// 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);
@ -579,7 +578,7 @@ static void calcTypeName(const Type *Ty,
/// 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.
@ -614,6 +613,11 @@ static void printTypeInt(std::ostream &Out, const Type *Ty,
///
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
@ -629,7 +633,7 @@ void llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
// 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 != '\\') {
@ -675,7 +679,7 @@ static const char *getPredicateText(unsigned predicate) {
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)) {
@ -873,7 +877,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *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 << ' ';
@ -936,6 +940,12 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
///
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);
@ -952,13 +962,13 @@ void llvm::WriteAsOperand(std::ostream &Out, const Value *V, bool PrintType,
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) {
@ -968,10 +978,19 @@ public:
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); }
@ -1176,7 +1195,7 @@ void AssemblyWriter::printModule(const Module *M) {
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;
@ -1195,7 +1214,7 @@ static void PrintLinkage(GlobalValue::LinkageTypes LT, std::ostream &Out) {
static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
std::ostream &Out) {
raw_ostream &Out) {
switch (Vis) {
default: assert(0 && "Invalid visibility style!");
case GlobalValue::DefaultVisibility: break;
@ -1705,74 +1724,75 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
//===----------------------------------------------------------------------===//
void Module::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
raw_os_ostream OS(o);
print(OS, AAW);
}
void Module::print(raw_ostream &OS, AssemblyAnnotationWriter *AAW) const {
SlotTracker SlotTable(this);
AssemblyWriter W(o, SlotTable, this, AAW);
AssemblyWriter W(OS, 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);
}
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);
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(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); }

5
lib/VMCore/Module.cpp
View File

@ -88,11 +88,6 @@ Module::~Module() {
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;

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

@ -21,6 +21,7 @@
#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>
@ -71,12 +72,12 @@ namespace {
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";
@ -84,7 +85,7 @@ namespace {
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.
@ -235,7 +236,7 @@ int main(int argc, char **argv) {
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);