From 4f9463772b10638c51226cbfb9b10e06f22d1cbc Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 28 Oct 2002 01:03:43 +0000 Subject: [PATCH] Move addPassesToEmitAssembly from TargetMachine to UltraSparc because it really is sparc specific. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4308 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Target/SparcV9/SparcV9Internals.h | 3 +- lib/Target/SparcV9/SparcV9TargetMachine.cpp | 119 +++++++++++++++++++ lib/Target/TargetMachine.cpp | 122 -------------------- 3 files changed, 121 insertions(+), 123 deletions(-) diff --git a/lib/Target/SparcV9/SparcV9Internals.h b/lib/Target/SparcV9/SparcV9Internals.h index 4304518c693..72691a2613f 100644 --- a/lib/Target/SparcV9/SparcV9Internals.h +++ b/lib/Target/SparcV9/SparcV9Internals.h @@ -709,7 +709,6 @@ public: //--------------------------------------------------------------------------- class UltraSparc : public TargetMachine { -private: UltraSparcInstrInfo instrInfo; UltraSparcSchedInfo schedInfo; UltraSparcRegInfo regInfo; @@ -726,6 +725,8 @@ public: virtual const MachineCacheInfo &getCacheInfo() const { return cacheInfo; } virtual const MachineOptInfo &getOptInfo() const { return optInfo; } + virtual void addPassesToEmitAssembly(PassManager &PM, std::ostream &Out); + // getPrologEpilogCodeInserter - Inserts prolog/epilog code. virtual Pass* getPrologEpilogInsertionPass(); diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp index 2484acebf24..7ec0a348b1a 100644 --- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp +++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp @@ -8,7 +8,19 @@ #include "SparcInternals.h" #include "llvm/Target/Sparc.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/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 "Support/CommandLine.h" using std::cerr; // Build the MachineInstruction Description Array... @@ -20,6 +32,19 @@ const MachineInstrDescriptor SparcMachineInstrDesc[] = { #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) @@ -88,6 +113,47 @@ UltraSparcFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, return offset; } +//===---------------------------------------------------------------------===// +// Default code generation passes. +// +// Native code generation for a specified target. +//===---------------------------------------------------------------------===// + +class ConstructMachineCodeForFunction : public FunctionPass { + TargetMachine &Target; +public: + ConstructMachineCodeForFunction(TargetMachine &T) : Target(T) {} + + const char *getPassName() const { + return "ConstructMachineCodeForFunction"; + } + + bool runOnFunction(Function &F) { + MachineFunction::construct(&F, Target); + return false; + } +}; + +struct FreeMachineCodeForFunction : public FunctionPass { + const char *getPassName() const { return "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; + } +}; + + //--------------------------------------------------------------------------- // class UltraSparcMachine @@ -114,3 +180,56 @@ UltraSparc::UltraSparc() maxAtomicMemOpWordSize = 8; } + +// 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 MachineFunction object for this fn. + PM.add(new ConstructMachineCodeForFunction(*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)); + + if (!DisableSched) + PM.add(createInstructionSchedulingWithSSAPass(*this)); + + PM.add(getRegisterAllocator(*this)); + + PM.add(getPrologEpilogInsertionPass()); + + if (!DisablePeephole) + PM.add(createPeepholeOptsPass(*this)); + + PM.add(MappingInfoForFunction(Out)); + + // Output assembly language to the .s file. Assembly emission is split into + // two parts: Function output and Global value output. This is because + // function output is pipelined with all of the rest of code generation stuff, + // allowing machine code representations for functions to be free'd after the + // function has been emitted. + // + PM.add(getFunctionAsmPrinterPass(Out)); + PM.add(new FreeMachineCodeForFunction()); // Free stuff no longer needed + + // Emit Module level assembly after all of the functions have been processed. + PM.add(getModuleAsmPrinterPass(Out)); + + // Emit bytecode to the assembly file into its special section next + PM.add(getEmitBytecodeToAsmPass(Out)); + PM.add(getFunctionInfo(Out)); +} diff --git a/lib/Target/TargetMachine.cpp b/lib/Target/TargetMachine.cpp index a61a804088e..31277ff3cda 100644 --- a/lib/Target/TargetMachine.cpp +++ b/lib/Target/TargetMachine.cpp @@ -8,34 +8,7 @@ #include "llvm/Target/TargetMachine.h" #include "llvm/Target/MachineInstrInfo.h" #include "llvm/Target/MachineCacheInfo.h" -#include "llvm/CodeGen/PreSelection.h" -#include "llvm/CodeGen/StackSlots.h" -#include "llvm/CodeGen/InstrSelection.h" -#include "llvm/CodeGen/InstrScheduling.h" -#include "llvm/CodeGen/RegisterAllocation.h" -#include "llvm/CodeGen/PeepholeOpts.h" -#include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineCodeForInstruction.h" -#include "llvm/Reoptimizer/Mapping/MappingInfo.h" -#include "llvm/Reoptimizer/Mapping/FInfo.h" -#include "llvm/Transforms/Scalar.h" -#include "Support/CommandLine.h" -#include "llvm/PassManager.h" #include "llvm/Function.h" -#include "llvm/DerivedTypes.h" - -//--------------------------------------------------------------------------- -// 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")); //--------------------------------------------------------------------------- // class TargetMachine @@ -71,101 +44,6 @@ TargetMachine::findOptimalStorageSize(const Type* ty) const } -//===---------------------------------------------------------------------===// -// Default code generation passes. -// -// 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 "ConstructMachineCodeForFunction"; - } - - bool runOnFunction(Function &F) { - MachineFunction::construct(&F, Target); - return false; - } -}; - -struct FreeMachineCodeForFunction : public FunctionPass { - const char *getPassName() const { return "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 -TargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) -{ - // Construct and initialize the MachineFunction object for this fn. - PM.add(new ConstructMachineCodeForFunction(*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)); - - if (!DisableSched) - PM.add(createInstructionSchedulingWithSSAPass(*this)); - - PM.add(getRegisterAllocator(*this)); - - PM.add(getPrologEpilogInsertionPass()); - - if (!DisablePeephole) - PM.add(createPeepholeOptsPass(*this)); - - PM.add(MappingInfoForFunction(Out)); - - // Output assembly language to the .s file. Assembly emission is split into - // two parts: Function output and Global value output. This is because - // function output is pipelined with all of the rest of code generation stuff, - // allowing machine code representations for functions to be free'd after the - // function has been emitted. - // - PM.add(getFunctionAsmPrinterPass(Out)); - PM.add(new FreeMachineCodeForFunction()); // Free stuff no longer needed - - // Emit Module level assembly after all of the functions have been processed. - PM.add(getModuleAsmPrinterPass(Out)); - - // Emit bytecode to the assembly file into its special section next - PM.add(getEmitBytecodeToAsmPass(Out)); - PM.add(getFunctionInfo(Out)); -} - - //--------------------------------------------------------------------------- // class MachineInstructionInfo // Interface to description of machine instructions -- 2.34.1