X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FTarget%2FSparcV9%2FSparcV9TargetMachine.cpp;h=faed36c32a8e18fddde85239bb43f7330f564ab8;hb=601899d196db343670943285c8f989534710937e;hp=7ec76fc05290cd723e4adcab8db280073bf3a651;hpb=5acd166ff52fd34824fec046308631998e87626c;p=oota-llvm.git diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp index 7ec76fc0529..faed36c32a8 100644 --- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp +++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp @@ -6,18 +6,21 @@ //===----------------------------------------------------------------------===// #include "SparcInternals.h" -#include "llvm/Target/Sparc.h" -#include "llvm/CodeGen/InstrScheduling.h" +#include "llvm/Target/TargetMachineImpls.h" +#include "llvm/Function.h" +#include "llvm/PassManager.h" +#include "llvm/Transforms/Scalar.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/PreSelection.h" +#include "llvm/CodeGen/StackSlots.h" +#include "llvm/CodeGen/PeepholeOpts.h" #include "llvm/CodeGen/InstrSelection.h" -#include "llvm/CodeGen/MachineCodeForInstruction.h" -#include "llvm/CodeGen/MachineCodeForMethod.h" +#include "llvm/CodeGen/InstrScheduling.h" #include "llvm/CodeGen/RegisterAllocation.h" +#include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/Reoptimizer/Mapping/MappingInfo.h" #include "llvm/Reoptimizer/Mapping/FInfo.h" -#include "llvm/Function.h" -#include "llvm/BasicBlock.h" -#include "llvm/PassManager.h" -#include +#include "Support/CommandLine.h" using std::cerr; // Build the MachineInstruction Description Array... @@ -25,10 +28,23 @@ const MachineInstrDescriptor SparcMachineInstrDesc[] = { #define I(ENUM, OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \ NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS) \ { OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \ - NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS }, + NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS, 0 }, #include "SparcInstr.def" }; +//--------------------------------------------------------------------------- +// Command line options to control choice of code generation passes. +//--------------------------------------------------------------------------- + +static cl::opt DisablePreSelect("nopreselect", + cl::desc("Disable preselection pass")); + +static cl::opt DisableSched("nosched", + cl::desc("Disable local scheduling pass")); + +static cl::opt DisablePeephole("nopeephole", + cl::desc("Disable peephole optimization pass")); + //---------------------------------------------------------------------------- // allocateSparcTargetMachine - Allocate and return a subclass of TargetMachine // that implements the Sparc backend. (the llvm/CodeGen/Sparc.h interface) @@ -48,7 +64,7 @@ TargetMachine *allocateSparcTargetMachine() { return new UltraSparc(); } //--------------------------------------------------------------------------- int -UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineCodeForMethod& , +UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineFunction& , bool& pos) const { pos = false; // static stack area grows downwards @@ -56,7 +72,7 @@ UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineCodeForMethod& , } int -UltraSparcFrameInfo::getRegSpillAreaOffset(MachineCodeForMethod& mcInfo, +UltraSparcFrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo, bool& pos) const { mcInfo.freezeAutomaticVarsArea(); // ensure no more auto vars are added @@ -67,7 +83,7 @@ UltraSparcFrameInfo::getRegSpillAreaOffset(MachineCodeForMethod& mcInfo, } int -UltraSparcFrameInfo::getTmpAreaOffset(MachineCodeForMethod& mcInfo, +UltraSparcFrameInfo::getTmpAreaOffset(MachineFunction& mcInfo, bool& pos) const { mcInfo.freezeAutomaticVarsArea(); // ensure no more auto vars are added @@ -81,7 +97,7 @@ UltraSparcFrameInfo::getTmpAreaOffset(MachineCodeForMethod& mcInfo, } int -UltraSparcFrameInfo::getDynamicAreaOffset(MachineCodeForMethod& mcInfo, +UltraSparcFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, bool& pos) const { // Dynamic stack area grows downwards starting at top of opt-args area. @@ -90,12 +106,13 @@ UltraSparcFrameInfo::getDynamicAreaOffset(MachineCodeForMethod& mcInfo, // dynamic-size alloca. pos = false; unsigned int optArgsSize = mcInfo.getMaxOptionalArgsSize(); + if (int extra = optArgsSize % getStackFrameSizeAlignment()) + optArgsSize += (getStackFrameSizeAlignment() - extra); int offset = optArgsSize + FirstOptionalOutgoingArgOffsetFromSP; assert((offset - OFFSET) % getStackFrameSizeAlignment() == 0); return offset; } - //--------------------------------------------------------------------------- // class UltraSparcMachine // @@ -108,79 +125,48 @@ UltraSparcFrameInfo::getDynamicAreaOffset(MachineCodeForMethod& mcInfo, //--------------------------------------------------------------------------- UltraSparc::UltraSparc() - : TargetMachine("UltraSparc-Native"), - instrInfo(*this), + : TargetMachine("UltraSparc-Native", 4), schedInfo(*this), regInfo(*this), frameInfo(*this), - cacheInfo(*this) -{ - optSizeForSubWordData = 4; - minMemOpWordSize = 8; - maxAtomicMemOpWordSize = 8; + cacheInfo(*this), + optInfo(*this) { } - -//===---------------------------------------------------------------------===// -// GenerateCodeForTarget Pass -// -// Native code generation for a specified target. -//===---------------------------------------------------------------------===// - -class ConstructMachineCodeForFunction : public FunctionPass { - TargetMachine &Target; -public: - inline ConstructMachineCodeForFunction(TargetMachine &T) : Target(T) {} - - const char *getPassName() const { - return "Sparc ConstructMachineCodeForFunction"; - } - - bool runOnFunction(Function &F) { - MachineCodeForMethod::construct(&F, Target); - return false; - } -}; - -struct FreeMachineCodeForFunction : public FunctionPass { - const char *getPassName() const { return "Sparc FreeMachineCodeForFunction"; } - - 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; - } -}; - // addPassesToEmitAssembly - This method controls the entire code generation // process for the ultra sparc. // -void UltraSparc::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) { - // Construct and initialize the MachineCodeForMethod object for this fn. - PM.add(new ConstructMachineCodeForFunction(*this)); +bool UltraSparc::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) +{ + // Construct and initialize the MachineFunction object for this fn. + PM.add(createMachineCodeConstructionPass(*this)); + + //Insert empty stackslots in the stack frame of each function + //so %fp+offset-8 and %fp+offset-16 are empty slots now! + PM.add(createStackSlotsPass(*this)); + + // Specialize LLVM code for this target machine and then + // run basic dataflow optimizations on LLVM code. + if (!DisablePreSelect) + { + PM.add(createPreSelectionPass(*this)); + /* PM.add(createReassociatePass()); */ + PM.add(createLICMPass()); + PM.add(createGCSEPass()); + } PM.add(createInstructionSelectionPass(*this)); - PM.add(createInstructionSchedulingWithSSAPass(*this)); + if (!DisableSched) + PM.add(createInstructionSchedulingWithSSAPass(*this)); PM.add(getRegisterAllocator(*this)); - - //PM.add(new OptimizeLeafProcedures()); - //PM.add(new DeleteFallThroughBranches()); - //PM.add(new RemoveChainedBranches()); // should be folded with previous - //PM.add(new RemoveRedundantOps()); // operations with %g0, NOP, etc. - - PM.add(createPrologEpilogCodeInserter(*this)); + + PM.add(getPrologEpilogInsertionPass()); + + if (!DisablePeephole) + PM.add(createPeepholeOptsPass(*this)); PM.add(MappingInfoForFunction(Out)); @@ -190,15 +176,14 @@ void UltraSparc::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) { // allowing machine code representations for functions to be free'd after the // function has been emitted. // - PM.add(getFunctionAsmPrinterPass(PM, Out)); - PM.add(new FreeMachineCodeForFunction()); // Free stuff no longer needed + PM.add(getFunctionAsmPrinterPass(Out)); + PM.add(createMachineCodeDestructionPass()); // Free stuff no longer needed // Emit Module level assembly after all of the functions have been processed. - PM.add(getModuleAsmPrinterPass(PM, Out)); + PM.add(getModuleAsmPrinterPass(Out)); - // Emit bytecode to the sparc assembly file into its special section next + // Emit bytecode to the assembly file into its special section next PM.add(getEmitBytecodeToAsmPass(Out)); PM.add(getFunctionInfo(Out)); - + return false; } -