X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FMachineFunction.cpp;h=02646de18fd1610babe3205cfe12f3b1359e116a;hb=e165a78551a91d8420cd8f074d97701e8788f8b5;hp=66497d964a8162af89c23acaa9e3f4d3d2fa4c7c;hpb=07f32d48f1e16bcdc621985549548a5849215238;p=oota-llvm.git diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index 66497d964a8..02646de18fd 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -1,100 +1,269 @@ //===-- MachineFunction.cpp -----------------------------------------------===// -// +// // The LLVM Compiler Infrastructure // // This file was developed by the LLVM research group and 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/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineInstr.h" -#include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/SSARegMap.h" -#include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineConstantPool.h" +#include "llvm/CodeGen/MachineJumpTableInfo.h" +#include "llvm/CodeGen/Passes.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetFrameInfo.h" -#include "llvm/Target/TargetCacheInfo.h" #include "llvm/Function.h" -#include "llvm/iOther.h" -#include "llvm/Pass.h" +#include "llvm/Instructions.h" +#include "llvm/Support/LeakDetector.h" +#include "llvm/Support/GraphWriter.h" +#include "llvm/Config/config.h" +#include +#include +#include + using namespace llvm; static AnnotationID MF_AID( - AnnotationManager::getID("CodeGen::MachineCodeForFunction")); + AnnotationManager::getID("CodeGen::MachineCodeForFunction")); namespace { - struct Printer : public FunctionPass { + struct Printer : public MachineFunctionPass { + std::ostream *OS; + const std::string Banner; + + Printer (std::ostream *_OS, const std::string &_Banner) : + OS (_OS), Banner (_Banner) { } + const char *getPassName() const { return "MachineFunction Printer"; } virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); } - bool runOnFunction(Function &F) { - MachineFunction::get(&F).dump(); + bool runOnMachineFunction(MachineFunction &MF) { + (*OS) << Banner; + MF.print (*OS); return false; } }; } -FunctionPass *llvm::createMachineFunctionPrinterPass() { - return new Printer(); +/// 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 Deleter : public MachineFunctionPass { + 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; + } + }; +} + +/// 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(); } + //===---------------------------------------------------------------------===// // 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 (Parent != toList.Parent) + for (; first != last; ++first) + first->Parent = toList.Parent; +} + MachineFunction::MachineFunction(const Function *F, const TargetMachine &TM) - : Annotation(MF_AID), Fn(F), Target(TM) { + : Annotation(MF_AID), Fn(F), Target(TM), UsedPhysRegs(0) { SSARegMapping = new SSARegMap(); - MFInfo = new MachineFunctionInfo(*this); + MFInfo = 0; FrameInfo = new MachineFrameInfo(); - ConstantPool = new MachineConstantPool(); + ConstantPool = new MachineConstantPool(TM.getTargetData()); + JumpTableInfo = new MachineJumpTableInfo(TM.getTargetData()); + BasicBlocks.Parent = this; } -MachineFunction::~MachineFunction() { +MachineFunction::~MachineFunction() { + BasicBlocks.clear(); delete SSARegMapping; delete MFInfo; delete FrameInfo; delete ConstantPool; + delete JumpTableInfo; + delete[] UsedPhysRegs; } void MachineFunction::dump() const { print(std::cerr); } void MachineFunction::print(std::ostream &OS) const { - OS << "\n" << *(Value*)Fn->getFunctionType() << " \"" << Fn->getName() - << "\"\n"; + 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); - for (const_iterator BB = begin(); BB != end(); ++BB) { - const BasicBlock *LBB = BB->getBasicBlock(); - OS << "\n" << LBB->getName() << " (" << (const void*)LBB << "):\n"; - for (MachineBasicBlock::const_iterator I = BB->begin(); I != BB->end();++I){ - OS << "\t"; - (*I)->print(OS, Target); + const MRegisterInfo *MRI = getTarget().getRegisterInfo(); + + if (livein_begin() != livein_end()) { + OS << "Live Ins:"; + for (livein_iterator I = livein_begin(), E = livein_end(); I != E; ++I) { + if (MRI) + OS << " " << MRI->getName(I->first); + else + OS << " Reg #" << I->first; + } + OS << "\n"; + } + if (liveout_begin() != liveout_end()) { + OS << "Live Outs:"; + for (liveout_iterator I = liveout_begin(), E = liveout_end(); I != E; ++I) + if (MRI) + OS << " " << MRI->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 + std::string Filename = "/tmp/cfg." + getFunction()->getName() + ".dot"; + std::cerr << "Writing '" << Filename << "'... "; + std::ofstream F(Filename.c_str()); + + if (!F) { + std::cerr << " error opening file for writing!\n"; + return; + } + + WriteGraph(F, this); + F.close(); + std::cerr << "\n"; + +#ifdef HAVE_GRAPHVIZ + std::cerr << "Running 'Graphviz' program... " << std::flush; + if (system((LLVM_PATH_GRAPHVIZ " " + Filename).c_str())) { + std::cerr << "Error viewing graph: 'Graphviz' not in path?\n"; + } else { + system(("rm " + Filename).c_str()); + return; } - OS << "\nEnd function \"" << Fn->getName() << "\"\n\n"; +#endif // HAVE_GRAPHVIZ + +#ifdef HAVE_GV + std::cerr << "Running 'dot' program... " << std::flush; + if (system(("dot -Tps -Nfontname=Courier -Gsize=7.5,10 " + Filename + + " > /tmp/cfg.tempgraph.ps").c_str())) { + std::cerr << "Error running dot: 'dot' not in path?\n"; + } else { + std::cerr << "\n"; + system("gv /tmp/cfg.tempgraph.ps"); + } + system(("rm " + Filename + " /tmp/cfg.tempgraph.ps").c_str()); + return; +#endif // HAVE_GV +#endif // NDEBUG + std::cerr << "MachineFunction::viewCFG is only available in debug builds on " + << "systems with Graphviz or gv!\n"; + +#ifndef NDEBUG + system(("rm " + Filename).c_str()); +#endif } +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. @@ -102,7 +271,7 @@ void MachineFunction::print(std::ostream &OS) const { // 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) { @@ -113,9 +282,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!"); } @@ -136,37 +303,28 @@ void MachineFunction::clearSSARegMap() { // MachineFrameInfo implementation //===----------------------------------------------------------------------===// -/// CreateStackObject - Create a stack object for a value of the specified type. -/// -int MachineFrameInfo::CreateStackObject(const Type *Ty, const TargetData &TD) { - return CreateStackObject(TD.getTypeSize(Ty), TD.getTypeAlignment(Ty)); -} - -int MachineFrameInfo::CreateStackObject(const TargetRegisterClass *RC) { - return CreateStackObject(RC->getSize(), RC->getAlignment()); -} - - void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{ - int ValOffset = MF.getTarget().getFrameInfo().getOffsetOfLocalArea(); + int ValOffset = MF.getTarget().getFrameInfo()->getOffsetOfLocalArea(); for (unsigned i = 0, e = Objects.size(); i != e; ++i) { const StackObject &SO = Objects[i]; - OS << " is "; + OS << " : "; if (SO.Size == 0) OS << "variable sized"; else - OS << SO.Size << " byte" << (SO.Size != 1 ? "s" : " "); - + 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) { - int Off = SO.SPOffset + ValOffset; + int Off = SO.SPOffset - ValOffset; OS << " at location [SP"; if (Off > 0) - OS << "+" << Off; + OS << "+" << Off; else if (Off < 0) - OS << Off; + OS << Off; OS << "]"; } OS << "\n"; @@ -182,180 +340,81 @@ void MachineFrameInfo::dump(const MachineFunction &MF) const { //===----------------------------------------------------------------------===// -// MachineConstantPool implementation +// MachineJumpTableInfo implementation //===----------------------------------------------------------------------===// -void MachineConstantPool::print(std::ostream &OS) const { - for (unsigned i = 0, e = Constants.size(); i != e; ++i) - OS << " is" << *(Value*)Constants[i] << "\n"; +/// getJumpTableIndex - Create a new jump table entry in the jump table info +/// or return an existing one. +/// +unsigned MachineJumpTableInfo::getJumpTableIndex( + std::vector &DestBBs) { + 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; } -void MachineConstantPool::dump() const { print(std::cerr); } - -//===----------------------------------------------------------------------===// -// MachineFunctionInfo implementation -//===----------------------------------------------------------------------===// -static unsigned -ComputeMaxOptionalArgsSize(const TargetMachine& target, const Function *F, - unsigned &maxOptionalNumArgs) -{ - const TargetFrameInfo &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 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.getTargetData().getTypeSize(callInst-> - getOperand(i)->getType()); - } - - if (maxSize < sizeForThisCall) - maxSize = sizeForThisCall; - - if ((int)maxOptionalNumArgs < numExtra) - maxOptionalNumArgs = (unsigned) numExtra; - } - - return maxSize; +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"; + } } -// 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 -SizeToAlignment(unsigned 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.getTargetData().getDoubleAlignment()) - return sz; +unsigned MachineJumpTableInfo::getEntrySize() const { + return TD->getPointerSize(); } - -void MachineFunctionInfo::CalculateArgSize() { - maxOptionalArgsSize = ComputeMaxOptionalArgsSize(MF.getTarget(), - MF.getFunction(), - maxOptionalNumArgs); - staticStackSize = maxOptionalArgsSize - + MF.getTarget().getFrameInfo().getMinStackFrameSize(); +unsigned MachineJumpTableInfo::getAlignment() const { + return TD->getPointerAlignment(); } -int -MachineFunctionInfo::computeOffsetforLocalVar(const Value* val, - unsigned &getPaddedSize, - unsigned sizeToUse) -{ - if (sizeToUse == 0) - sizeToUse = MF.getTarget().findOptimalStorageSize(val->getType()); - unsigned align = SizeToAlignment(sizeToUse, MF.getTarget()); - - bool growUp; - int firstOffset = MF.getTarget().getFrameInfo().getFirstAutomaticVarOffset(MF, - growUp); - int offset = growUp? firstOffset + getAutomaticVarsSize() - : firstOffset - (getAutomaticVarsSize() + sizeToUse); +void MachineJumpTableInfo::dump() const { print(std::cerr); } - int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, align); - getPaddedSize = sizeToUse + abs(aligned - offset); - return aligned; -} - - -int MachineFunctionInfo::allocateLocalVar(const Value* val, - unsigned 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 - // - hash_map::const_iterator pair = offsets.find(val); - if (pair != offsets.end()) - return pair->second; - - unsigned getPaddedSize; - unsigned offset = computeOffsetforLocalVar(val, getPaddedSize, sizeToUse); - offsets[val] = offset; - incrementAutomaticVarsSize(getPaddedSize); - return offset; -} +//===----------------------------------------------------------------------===// +// MachineConstantPool implementation +//===----------------------------------------------------------------------===// -int -MachineFunctionInfo::allocateSpilledValue(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 size = MF.getTarget().getTargetData().getTypeSize(type); - unsigned char align = MF.getTarget().getTargetData().getTypeAlignment(type); +/// 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; - bool growUp; - int firstOffset = MF.getTarget().getFrameInfo().getRegSpillAreaOffset(MF, growUp); + // 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 == C && (Constants[i].Offset & AlignMask) == 0) + return i; - int offset = growUp? firstOffset + getRegSpillsSize() - : firstOffset - (getRegSpillsSize() + size); - - int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, align); - size += abs(aligned - offset); // include alignment padding in size + unsigned Offset = 0; + if (!Constants.empty()) { + Offset = Constants.back().Offset; + Offset += TD->getTypeSize(Constants.back().Val->getType()); + Offset = (Offset+AlignMask)&~AlignMask; + } - incrementRegSpillsSize(size); // update size of reg. spills area - - return aligned; + Constants.push_back(MachineConstantPoolEntry(C, Offset)); + return Constants.size()-1; } -int -MachineFunctionInfo::pushTempValue(unsigned size) -{ - unsigned align = SizeToAlignment(size, MF.getTarget()); - - bool growUp; - int firstOffset = MF.getTarget().getFrameInfo().getTmpAreaOffset(MF, growUp); - - int offset = growUp? firstOffset + currentTmpValuesSize - : firstOffset - (currentTmpValuesSize + size); - - int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, - align); - size += abs(aligned - offset); // include alignment padding in size - - incrementTmpAreaSize(size); // update "current" size of tmp area - return aligned; -} - -void MachineFunctionInfo::popAllTempValues() { - resetTmpAreaSize(); // clear tmp area to reuse +void MachineConstantPool::print(std::ostream &OS) const { + for (unsigned i = 0, e = Constants.size(); i != e; ++i) { + OS << " is" << *(Value*)Constants[i].Val; + OS << " , offset=" << Constants[i].Offset; + OS << "\n"; + } } +void MachineConstantPool::dump() const { print(std::cerr); }