X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FMachineFunction.cpp;h=c762ae567c8a928806f42b1321d47154f4efdfbe;hb=72623366c4b5116e36c9acb176f9704b4e3c9a3f;hp=4de55f4596e9dfc436b711fee273a6056b9c6c87;hpb=c0b9dc5be79f009d260edb5cd5e1d8346587aaa2;p=oota-llvm.git diff --git a/lib/CodeGen/MachineFunction.cpp b/lib/CodeGen/MachineFunction.cpp index 4de55f4596e..c762ae567c8 100644 --- a/lib/CodeGen/MachineFunction.cpp +++ b/lib/CodeGen/MachineFunction.cpp @@ -1,44 +1,56 @@ //===-- 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/DerivedTypes.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/TargetData.h" +#include "llvm/Target/TargetLowering.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/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")); +// Out of line virtual function to home classes. +void MachineFunctionPass::virtfn() {} namespace { - struct Printer : public MachineFunctionPass { + struct VISIBILITY_HIDDEN Printer : public MachineFunctionPass { + static char ID; + std::ostream *OS; const std::string Banner; - Printer (std::ostream *_OS, const std::string &_Banner) : - OS (_OS), Banner (_Banner) { } + Printer (std::ostream *_OS, const std::string &_Banner) + : MachineFunctionPass((intptr_t)&ID), OS (_OS), Banner (_Banner) { } const char *getPassName() const { return "MachineFunction Printer"; } @@ -52,59 +64,236 @@ namespace { return false; } }; + char Printer::ID = 0; } /// 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) { + 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; +} + +/// 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) { SSARegMapping = new SSARegMap(); - MFInfo = new MachineFunctionInfo(*this); + MFInfo = 0; FrameInfo = new MachineFrameInfo(); - ConstantPool = new MachineConstantPool(); + ConstantPool = new MachineConstantPool(TM.getTargetData()); + UsedPhysRegs.resize(TM.getRegisterInfo()->getNumRegs()); + + // 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() { +MachineFunction::~MachineFunction() { + BasicBlocks.clear(); delete SSARegMapping; 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(std::cerr); } + +void MachineFunction::dump() const { print(*cerr.stream()); } 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; + + if (I->second) + OS << " in VR#" << I->second << " "; } + 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"; } - OS << "\nEnd function \"" << Fn->getName() << "\"\n\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. @@ -112,7 +301,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) { @@ -144,37 +333,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; + int64_t 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"; @@ -185,185 +365,119 @@ void MachineFrameInfo::print(const MachineFunction &MF, std::ostream &OS) const{ } void MachineFrameInfo::dump(const MachineFunction &MF) const { - print(MF, std::cerr); -} - - -//===----------------------------------------------------------------------===// -// MachineConstantPool implementation -//===----------------------------------------------------------------------===// - -void MachineConstantPool::print(std::ostream &OS) const { - for (unsigned i = 0, e = Constants.size(); i != e; ++i) - OS << " is" << *(Value*)Constants[i] << "\n"; + print(MF, *cerr.stream()); } -void MachineConstantPool::dump() const { print(std::cerr); } //===----------------------------------------------------------------------===// -// MachineFunctionInfo implementation +// MachineJumpTableInfo 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; - } +/// 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; - 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 -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; + JumpTables.push_back(MachineJumpTableEntry(DestBBs)); + return JumpTables.size()-1; } -void MachineFunctionInfo::CalculateArgSize() { - maxOptionalArgsSize = ComputeMaxOptionalArgsSize(MF.getTarget(), - MF.getFunction(), - maxOptionalNumArgs); - staticStackSize = maxOptionalArgsSize - + MF.getTarget().getFrameInfo().getMinStackFrameSize(); +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 -MachineFunctionInfo::computeOffsetforLocalVar(const Value* val, - unsigned &getPaddedSize, - unsigned sizeToUse) -{ - if (sizeToUse == 0) - sizeToUse = MF.getTarget().findOptimalStorageSize(val->getType()); - unsigned align = SizeToAlignment(sizeToUse, MF.getTarget()); +void MachineJumpTableInfo::dump() const { print(*cerr.stream()); } - bool growUp; - int firstOffset = MF.getTarget().getFrameInfo().getFirstAutomaticVarOffset(MF, - growUp); - int offset = growUp? firstOffset + getAutomaticVarsSize() - : firstOffset - (getAutomaticVarsSize() + sizeToUse); - int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, align); - getPaddedSize = sizeToUse + abs(aligned - offset); +//===----------------------------------------------------------------------===// +// MachineConstantPool implementation +//===----------------------------------------------------------------------===// - return aligned; +const Type *MachineConstantPoolEntry::getType() const { + if (isMachineConstantPoolEntry()) + return Val.MachineCPVal->getType(); + return Val.ConstVal->getType(); } - -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::~MachineConstantPool() { + for (unsigned i = 0, e = Constants.size(); i != e; ++i) + if (Constants[i].isMachineConstantPoolEntry()) + delete Constants[i].Val.MachineCPVal; } -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!"); +/// 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; - unsigned size = MF.getTarget().getTargetData().getTypeSize(type); - unsigned char align = MF.getTarget().getTargetData().getTypeAlignment(type); + // 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; - bool growUp; - int firstOffset = MF.getTarget().getFrameInfo().getRegSpillAreaOffset(MF, growUp); + unsigned Offset = 0; + if (!Constants.empty()) { + Offset = Constants.back().getOffset(); + Offset += TD->getTypeSize(Constants.back().getType()); + Offset = (Offset+AlignMask)&~AlignMask; + } - int offset = growUp? firstOffset + getRegSpillsSize() - : firstOffset - (getRegSpillsSize() + size); + Constants.push_back(MachineConstantPoolEntry(C, Offset)); + return Constants.size()-1; +} - int aligned = MF.getTarget().getFrameInfo().adjustAlignment(offset, growUp, align); - size += abs(aligned - offset); // include alignment padding in size +unsigned MachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V, + unsigned Alignment) { + assert(Alignment && "Alignment must be specified!"); + if (Alignment > PoolAlignment) PoolAlignment = Alignment; - incrementRegSpillsSize(size); // update size of reg. spills area - - return aligned; + // 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->getTypeSize(Constants.back().getType()); + Offset = (Offset+AlignMask)&~AlignMask; + } + + Constants.push_back(MachineConstantPoolEntry(V, 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"; + if (Constants[i].isMachineConstantPoolEntry()) + Constants[i].Val.MachineCPVal->print(OS); + else + OS << *(Value*)Constants[i].Val.ConstVal; + OS << " , offset=" << Constants[i].getOffset(); + OS << "\n"; + } } +void MachineConstantPool::dump() const { print(*cerr.stream()); }