X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FMachineFunction.cpp;h=30896172883e431b5d45ed6305b243900a359d00;hb=63e3cd4e0f3731d6801ac24199652e4d7b4b3729;hp=c46c90632de80d298bd44ed1eb5a932867b6e56a;hpb=e316efc0e74442cffdda4889d30dca4fffcad749;p=oota-llvm.git diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index c46c90632de..30896172883 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -1,88 +1,310 @@ //===-- MachineFunction.cpp -----------------------------------------------===// -// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // Collect native machine code information for a function. This allows // target-specific information about the generated code to be stored with each // function. // //===----------------------------------------------------------------------===// -#include "llvm/CodeGen/MachineInstr.h" // For debug output -#include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineCodeForInstruction.h" +#include "llvm/DerivedTypes.h" +#include "llvm/CodeGen/MachineConstantPool.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/CodeGen/MachineFrameInfo.h" +#include "llvm/CodeGen/MachineInstr.h" +#include "llvm/CodeGen/MachineJumpTableInfo.h" +#include "llvm/CodeGen/MachineRegisterInfo.h" +#include "llvm/CodeGen/Passes.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Target/TargetLowering.h" #include "llvm/Target/TargetMachine.h" -#include "llvm/Target/MachineFrameInfo.h" -#include "llvm/Target/MachineCacheInfo.h" +#include "llvm/Target/TargetFrameInfo.h" #include "llvm/Function.h" -#include "llvm/iOther.h" -#include "llvm/Pass.h" -#include - -const int INVALID_FRAME_OFFSET = INT_MAX; // std::numeric_limits::max(); +#include "llvm/Instructions.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/GraphWriter.h" +#include "llvm/Support/LeakDetector.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Config/config.h" +#include +#include +using namespace llvm; static AnnotationID MF_AID( - AnnotationManager::getID("CodeGen::MachineCodeForFunction")); - + AnnotationManager::getID("CodeGen::MachineCodeForFunction")); -//===---------------------------------------------------------------------===// -// Code generation/destruction passes -//===---------------------------------------------------------------------===// +// Out of line virtual function to home classes. +void MachineFunctionPass::virtfn() {} namespace { - class ConstructMachineFunction : public FunctionPass { - TargetMachine &Target; - public: - ConstructMachineFunction(TargetMachine &T) : Target(T) {} - - const char *getPassName() const { - return "ConstructMachineFunction"; + struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass { + static char ID; + + std::ostream *OS; + const std::string Banner; + + Printer (std::ostream *_OS, const std::string &_Banner) + : MachineFunctionPass((intptr_t)&ID), OS (_OS), Banner (_Banner) { } + + const char *getPassName() const { return "MachineFunction Printer"; } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); } - - bool runOnFunction(Function &F) { - MachineFunction::construct(&F, Target); + + bool runOnMachineFunction(MachineFunction &MF) { + (*OS) << Banner; + MF.print (*OS); return false; } }; + char Printer::ID = 0; +} - struct DestroyMachineFunction : public FunctionPass { - const char *getPassName() const { return "FreeMachineFunction"; } - - static void freeMachineCode(Instruction &I) { - MachineCodeForInstruction::destroy(&I); - } - - bool runOnFunction(Function &F) { - for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) - for (BasicBlock::iterator I = FI->begin(), E = FI->end(); I != E; ++I) - MachineCodeForInstruction::get(I).dropAllReferences(); - - for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) - for_each(FI->begin(), FI->end(), freeMachineCode); - - return false; +/// Returns a newly-created MachineFunction Printer pass. The default output +/// stream is std::cerr; the default banner is empty. +/// +FunctionPass *llvm::createMachineFunctionPrinterPass(std::ostream *OS, + const std::string &Banner){ + return new Printer(OS, Banner); +} + +namespace { + struct VISIBILITY_HIDDEN Deleter : public MachineFunctionPass { + static char ID; + Deleter() : MachineFunctionPass((intptr_t)&ID) {} + + const char *getPassName() const { return "Machine Code Deleter"; } + + bool runOnMachineFunction(MachineFunction &MF) { + // Delete the annotation from the function now. + MachineFunction::destruct(MF.getFunction()); + return true; } }; + char Deleter::ID = 0; } -Pass *createMachineCodeConstructionPass(TargetMachine &Target) { - return new ConstructMachineFunction(Target); +/// MachineCodeDeletion Pass - This pass deletes all of the machine code for +/// the current function, which should happen after the function has been +/// emitted to a .s file or to memory. +FunctionPass *llvm::createMachineCodeDeleter() { + return new Deleter(); } -Pass *createMachineCodeDestructionPass() { - return new DestroyMachineFunction(); -} //===---------------------------------------------------------------------===// // MachineFunction implementation //===---------------------------------------------------------------------===// +MachineBasicBlock* ilist_traits::createSentinel() { + MachineBasicBlock* dummy = new MachineBasicBlock(); + LeakDetector::removeGarbageObject(dummy); + return dummy; +} + +void ilist_traits::transferNodesFromList( + iplist >& toList, + ilist_iterator first, + ilist_iterator last) { + // If splicing withing the same function, no change. + if (Parent == toList.Parent) return; + + for (; first != last; ++first) + first->setParent(toList.Parent); +} + +MachineFunction::MachineFunction(const Function *F, + const TargetMachine &TM) + : Annotation(MF_AID), Fn(F), Target(TM) { + RegInfo = new MachineRegisterInfo(*TM.getRegisterInfo()); + MFInfo = 0; + FrameInfo = new MachineFrameInfo(*TM.getFrameInfo()); + ConstantPool = new MachineConstantPool(TM.getTargetData()); + + // Set up jump table. + const TargetData &TD = *TM.getTargetData(); + bool IsPic = TM.getRelocationModel() == Reloc::PIC_; + unsigned EntrySize = IsPic ? 4 : TD.getPointerSize(); + unsigned Alignment = IsPic ? TD.getABITypeAlignment(Type::Int32Ty) + : TD.getPointerABIAlignment(); + JumpTableInfo = new MachineJumpTableInfo(EntrySize, Alignment); + + BasicBlocks.Parent = this; +} + +MachineFunction::~MachineFunction() { + BasicBlocks.clear(); + delete RegInfo; + delete MFInfo; + delete FrameInfo; + delete ConstantPool; + delete JumpTableInfo; +} + + +/// RenumberBlocks - This discards all of the MachineBasicBlock numbers and +/// recomputes them. This guarantees that the MBB numbers are sequential, +/// dense, and match the ordering of the blocks within the function. If a +/// specific MachineBasicBlock is specified, only that block and those after +/// it are renumbered. +void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { + if (empty()) { MBBNumbering.clear(); return; } + MachineFunction::iterator MBBI, E = end(); + if (MBB == 0) + MBBI = begin(); + else + MBBI = MBB; + + // Figure out the block number this should have. + unsigned BlockNo = 0; + if (MBBI != begin()) + BlockNo = prior(MBBI)->getNumber()+1; + + for (; MBBI != E; ++MBBI, ++BlockNo) { + if (MBBI->getNumber() != (int)BlockNo) { + // Remove use of the old number. + if (MBBI->getNumber() != -1) { + assert(MBBNumbering[MBBI->getNumber()] == &*MBBI && + "MBB number mismatch!"); + MBBNumbering[MBBI->getNumber()] = 0; + } + + // If BlockNo is already taken, set that block's number to -1. + if (MBBNumbering[BlockNo]) + MBBNumbering[BlockNo]->setNumber(-1); + + MBBNumbering[BlockNo] = MBBI; + MBBI->setNumber(BlockNo); + } + } + + // Okay, all the blocks are renumbered. If we have compactified the block + // numbering, shrink MBBNumbering now. + assert(BlockNo <= MBBNumbering.size() && "Mismatch!"); + MBBNumbering.resize(BlockNo); +} + + +void MachineFunction::dump() const { print(*cerr.stream()); } + +void MachineFunction::print(std::ostream &OS) const { + OS << "# Machine code for " << Fn->getName () << "():\n"; + + // Print Frame Information + getFrameInfo()->print(*this, OS); + + // Print JumpTable Information + getJumpTableInfo()->print(OS); + + // Print Constant Pool + getConstantPool()->print(OS); + + const TargetRegisterInfo *TRI = getTarget().getRegisterInfo(); + + if (!RegInfo->livein_empty()) { + OS << "Live Ins:"; + for (MachineRegisterInfo::livein_iterator + I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) { + if (TRI) + OS << " " << TRI->getName(I->first); + else + OS << " Reg #" << I->first; + + if (I->second) + OS << " in VR#" << I->second << " "; + } + OS << "\n"; + } + if (!RegInfo->liveout_empty()) { + OS << "Live Outs:"; + for (MachineRegisterInfo::liveout_iterator + I = RegInfo->liveout_begin(), E = RegInfo->liveout_end(); I != E; ++I) + if (TRI) + OS << " " << TRI->getName(*I); + else + OS << " Reg #" << *I; + OS << "\n"; + } + + for (const_iterator BB = begin(); BB != end(); ++BB) + BB->print(OS); + + OS << "\n# End machine code for " << Fn->getName () << "().\n\n"; +} + +/// CFGOnly flag - This is used to control whether or not the CFG graph printer +/// prints out the contents of basic blocks or not. This is acceptable because +/// this code is only really used for debugging purposes. +/// +static bool CFGOnly = false; + +namespace llvm { + template<> + struct DOTGraphTraits : public DefaultDOTGraphTraits { + static std::string getGraphName(const MachineFunction *F) { + return "CFG for '" + F->getFunction()->getName() + "' function"; + } + + static std::string getNodeLabel(const MachineBasicBlock *Node, + const MachineFunction *Graph) { + if (CFGOnly && Node->getBasicBlock() && + !Node->getBasicBlock()->getName().empty()) + return Node->getBasicBlock()->getName() + ":"; + + std::ostringstream Out; + if (CFGOnly) { + Out << Node->getNumber() << ':'; + return Out.str(); + } + + Node->print(Out); + + std::string OutStr = Out.str(); + if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); + + // Process string output to make it nicer... + for (unsigned i = 0; i != OutStr.length(); ++i) + if (OutStr[i] == '\n') { // Left justify + OutStr[i] = '\\'; + OutStr.insert(OutStr.begin()+i+1, 'l'); + } + return OutStr; + } + }; +} + +void MachineFunction::viewCFG() const +{ +#ifndef NDEBUG + ViewGraph(this, "mf" + getFunction()->getName()); +#else + cerr << "SelectionDAG::viewGraph is only available in debug builds on " + << "systems with Graphviz or gv!\n"; +#endif // NDEBUG +} + +void MachineFunction::viewCFGOnly() const +{ + CFGOnly = true; + viewCFG(); + CFGOnly = false; +} + // The next two methods are used to construct and to retrieve // the MachineCodeForFunction object for the given function. // construct() -- Allocates and initializes for a given function and target // get() -- Returns a handle to the object. // This should not be called before "construct()" // for a given Function. -// +// MachineFunction& MachineFunction::construct(const Function *Fn, const TargetMachine &Tar) { @@ -93,9 +315,7 @@ MachineFunction::construct(const Function *Fn, const TargetMachine &Tar) return *mcInfo; } -void -MachineFunction::destruct(const Function *Fn) -{ +void MachineFunction::destruct(const Function *Fn) { bool Deleted = Fn->deleteAnnotation(MF_AID); assert(Deleted && "Machine code did not exist for function!"); } @@ -107,201 +327,168 @@ MachineFunction& MachineFunction::get(const Function *F) return *mc; } -static unsigned -ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F, - unsigned &maxOptionalNumArgs) -{ - const MachineFrameInfo& frameInfo = target.getFrameInfo(); - - unsigned maxSize = 0; - - for (Function::const_iterator BB = F->begin(), BBE = F->end(); BB !=BBE; ++BB) - for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) - if (const CallInst *callInst = dyn_cast(&*I)) - { - unsigned numOperands = callInst->getNumOperands() - 1; - int numExtra = (int)numOperands-frameInfo.getNumFixedOutgoingArgs(); - if (numExtra <= 0) - continue; - - unsigned int sizeForThisCall; - if (frameInfo.argsOnStackHaveFixedSize()) - { - int argSize = frameInfo.getSizeOfEachArgOnStack(); - sizeForThisCall = numExtra * (unsigned) argSize; - } - else - { - assert(0 && "UNTESTED CODE: Size per stack argument is not " - "fixed on this architecture: use actual arg sizes to " - "compute MaxOptionalArgsSize"); - sizeForThisCall = 0; - for (unsigned i = 0; i < numOperands; ++i) - sizeForThisCall += target.DataLayout.getTypeSize(callInst-> - getOperand(i)->getType()); - } - - if (maxSize < sizeForThisCall) - maxSize = sizeForThisCall; - - if ((int)maxOptionalNumArgs < numExtra) - maxOptionalNumArgs = (unsigned) numExtra; - } - - return maxSize; -} - -// Align data larger than one L1 cache line on L1 cache line boundaries. -// Align all smaller data on the next higher 2^x boundary (4, 8, ...), -// but not higher than the alignment of the largest type we support -// (currently a double word). -- see class TargetData). -// -// This function is similar to the corresponding function in EmitAssembly.cpp -// but they are unrelated. This one does not align at more than a -// double-word boundary whereas that one might. -// -inline unsigned int -SizeToAlignment(unsigned int size, const TargetMachine& target) -{ - unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1); - if (size > (unsigned) cacheLineSize / 2) - return cacheLineSize; - else - for (unsigned sz=1; /*no condition*/; sz *= 2) - if (sz >= size || sz >= target.DataLayout.getDoubleAlignment()) - return sz; -} - +//===----------------------------------------------------------------------===// +// MachineFrameInfo implementation +//===----------------------------------------------------------------------===// -/*ctor*/ -MachineFunction::MachineFunction(const Function *F, - const TargetMachine& target) - : Annotation(MF_AID), - Fn(F), Target(target), staticStackSize(0), - automaticVarsSize(0), regSpillsSize(0), - maxOptionalArgsSize(0), maxOptionalNumArgs(0), - currentTmpValuesSize(0), maxTmpValuesSize(0), compiledAsLeaf(false), - spillsAreaFrozen(false), automaticVarsAreaFrozen(false) -{ - maxOptionalArgsSize = ComputeMaxOptionalArgsSize(target, Fn, - maxOptionalNumArgs); - staticStackSize = maxOptionalArgsSize - + target.getFrameInfo().getMinStackFrameSize(); +/// CreateFixedObject - Create a new object at a fixed location on the stack. +/// All fixed objects should be created before other objects are created for +/// efficiency. By default, fixed objects are immutable. This returns an +/// index with a negative value. +/// +int MachineFrameInfo::CreateFixedObject(uint64_t Size, int64_t SPOffset, + bool Immutable) { + assert(Size != 0 && "Cannot allocate zero size fixed stack objects!"); + Objects.insert(Objects.begin(), StackObject(Size, 1, SPOffset, Immutable)); + return -++NumFixedObjects; } -int -MachineFunction::computeOffsetforLocalVar(const TargetMachine& target, - const Value* val, - unsigned int& getPaddedSize, - unsigned int sizeToUse) -{ - if (sizeToUse == 0) - sizeToUse = target.findOptimalStorageSize(val->getType()); - unsigned int align = SizeToAlignment(sizeToUse, target); - - bool growUp; - int firstOffset = target.getFrameInfo().getFirstAutomaticVarOffset(*this, - growUp); - int offset = growUp? firstOffset + getAutomaticVarsSize() - : firstOffset - (getAutomaticVarsSize() + sizeToUse); - int aligned = target.getFrameInfo().adjustAlignment(offset, growUp, align); - getPaddedSize = sizeToUse + abs(aligned - offset); +void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{ + int ValOffset = MF.getTarget().getFrameInfo()->getOffsetOfLocalArea(); + + for (unsigned i = 0, e = Objects.size(); i != e; ++i) { + const StackObject &SO = Objects[i]; + OS << " : "; + if (SO.Size == 0) + OS << "variable sized"; + else + OS << "size is " << SO.Size << " byte" << (SO.Size != 1 ? "s," : ","); + OS << " alignment is " << SO.Alignment << " byte" + << (SO.Alignment != 1 ? "s," : ","); + + if (i < NumFixedObjects) + OS << " fixed"; + if (i < NumFixedObjects || SO.SPOffset != -1) { + int64_t Off = SO.SPOffset - ValOffset; + OS << " at location [SP"; + if (Off > 0) + OS << "+" << Off; + else if (Off < 0) + OS << Off; + OS << "]"; + } + OS << "\n"; + } - return aligned; + if (HasVarSizedObjects) + OS << " Stack frame contains variable sized objects\n"; } -int -MachineFunction::allocateLocalVar(const TargetMachine& target, - const Value* val, - unsigned int sizeToUse) -{ - assert(! automaticVarsAreaFrozen && - "Size of auto vars area has been used to compute an offset so " - "no more automatic vars should be allocated!"); - - // Check if we've allocated a stack slot for this value already - // - int offset = getOffset(val); - if (offset == INVALID_FRAME_OFFSET) - { - unsigned int getPaddedSize; - offset = computeOffsetforLocalVar(target, val, getPaddedSize, sizeToUse); - offsets[val] = offset; - incrementAutomaticVarsSize(getPaddedSize); - } - return offset; +void MachineFrameInfo::dump(const MachineFunction &MF) const { + print(MF, *cerr.stream()); } -int -MachineFunction::allocateSpilledValue(const TargetMachine& target, - const Type* type) -{ - assert(! spillsAreaFrozen && - "Size of reg spills area has been used to compute an offset so " - "no more register spill slots should be allocated!"); - - unsigned int size = target.DataLayout.getTypeSize(type); - unsigned char align = target.DataLayout.getTypeAlignment(type); - - bool growUp; - int firstOffset = target.getFrameInfo().getRegSpillAreaOffset(*this, growUp); - - int offset = growUp? firstOffset + getRegSpillsSize() - : firstOffset - (getRegSpillsSize() + size); - int aligned = target.getFrameInfo().adjustAlignment(offset, growUp, align); - size += abs(aligned - offset); // include alignment padding in size - - incrementRegSpillsSize(size); // update size of reg. spills area +//===----------------------------------------------------------------------===// +// MachineJumpTableInfo implementation +//===----------------------------------------------------------------------===// - return aligned; +/// getJumpTableIndex - Create a new jump table entry in the jump table info +/// or return an existing one. +/// +unsigned MachineJumpTableInfo::getJumpTableIndex( + const std::vector &DestBBs) { + assert(!DestBBs.empty() && "Cannot create an empty jump table!"); + for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) + if (JumpTables[i].MBBs == DestBBs) + return i; + + JumpTables.push_back(MachineJumpTableEntry(DestBBs)); + return JumpTables.size()-1; } -int -MachineFunction::pushTempValue(const TargetMachine& target, - unsigned int size) -{ - unsigned int align = SizeToAlignment(size, target); - bool growUp; - int firstOffset = target.getFrameInfo().getTmpAreaOffset(*this, growUp); +void MachineJumpTableInfo::print(std::ostream &OS) const { + // FIXME: this is lame, maybe we could print out the MBB numbers or something + // like {1, 2, 4, 5, 3, 0} + for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) { + OS << " has " << JumpTables[i].MBBs.size() + << " entries\n"; + } +} - int offset = growUp? firstOffset + currentTmpValuesSize - : firstOffset - (currentTmpValuesSize + size); +void MachineJumpTableInfo::dump() const { print(*cerr.stream()); } - int aligned = target.getFrameInfo().adjustAlignment(offset, growUp, align); - size += abs(aligned - offset); // include alignment padding in size - incrementTmpAreaSize(size); // update "current" size of tmp area +//===----------------------------------------------------------------------===// +// MachineConstantPool implementation +//===----------------------------------------------------------------------===// - return aligned; +const Type *MachineConstantPoolEntry::getType() const { + if (isMachineConstantPoolEntry()) + return Val.MachineCPVal->getType(); + return Val.ConstVal->getType(); } -void -MachineFunction::popAllTempValues(const TargetMachine& target) -{ - resetTmpAreaSize(); // clear tmp area to reuse +MachineConstantPool::~MachineConstantPool() { + for (unsigned i = 0, e = Constants.size(); i != e; ++i) + if (Constants[i].isMachineConstantPoolEntry()) + delete Constants[i].Val.MachineCPVal; } -int -MachineFunction::getOffset(const Value* val) const -{ - hash_map::const_iterator pair = offsets.find(val); - return (pair == offsets.end()) ? INVALID_FRAME_OFFSET : pair->second; +/// getConstantPoolIndex - Create a new entry in the constant pool or return +/// an existing one. User must specify an alignment in bytes for the object. +/// +unsigned MachineConstantPool::getConstantPoolIndex(Constant *C, + unsigned Alignment) { + assert(Alignment && "Alignment must be specified!"); + if (Alignment > PoolAlignment) PoolAlignment = Alignment; + + // Check to see if we already have this constant. + // + // FIXME, this could be made much more efficient for large constant pools. + unsigned AlignMask = (1 << Alignment)-1; + for (unsigned i = 0, e = Constants.size(); i != e; ++i) + if (Constants[i].Val.ConstVal == C && (Constants[i].Offset & AlignMask)== 0) + return i; + + unsigned Offset = 0; + if (!Constants.empty()) { + Offset = Constants.back().getOffset(); + Offset += TD->getABITypeSize(Constants.back().getType()); + Offset = (Offset+AlignMask)&~AlignMask; + } + + Constants.push_back(MachineConstantPoolEntry(C, Offset)); + return Constants.size()-1; } -void -MachineFunction::dump() const -{ - std::cerr << "\n" << Fn->getReturnType() - << " \"" << Fn->getName() << "\"\n"; +unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, + unsigned Alignment) { + assert(Alignment && "Alignment must be specified!"); + if (Alignment > PoolAlignment) PoolAlignment = Alignment; + + // Check to see if we already have this constant. + // + // FIXME, this could be made much more efficient for large constant pools. + unsigned AlignMask = (1 << Alignment)-1; + int Idx = V->getExistingMachineCPValue(this, Alignment); + if (Idx != -1) + return (unsigned)Idx; + + unsigned Offset = 0; + if (!Constants.empty()) { + Offset = Constants.back().getOffset(); + Offset += TD->getABITypeSize(Constants.back().getType()); + Offset = (Offset+AlignMask)&~AlignMask; + } - for (const_iterator BB = begin(); BB != end(); ++BB) { - std::cerr << "\n" << BB->getBasicBlock()->getName() << " (" - << (const void*)BB->getBasicBlock() << ")" << ":" << "\n"; - for (MachineBasicBlock::const_iterator I = BB->begin(); I != BB->end(); ++I) - std::cerr << "\t" << *I; + Constants.push_back(MachineConstantPoolEntry(V, Offset)); + return Constants.size()-1; +} + + +void MachineConstantPool::print(std::ostream &OS) const { + for (unsigned i = 0, e = Constants.size(); i != e; ++i) { + OS << " is"; + if (Constants[i].isMachineConstantPoolEntry()) + Constants[i].Val.MachineCPVal->print(OS); + else + OS << *(Value*)Constants[i].Val.ConstVal; + OS << " , offset=" << Constants[i].getOffset(); + OS << "\n"; } - std::cerr << "\nEnd function \"" << Fn->getName() << "\"\n\n"; } + +void MachineConstantPool::dump() const { print(*cerr.stream()); }