From f70e0c216c074bd2ae2b08178f5512849545db4e Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 28 Dec 2003 21:23:38 +0000 Subject: [PATCH] Clean up a lot of the code I added yesterday by exposing the IntrinsicLowering implementation from the TargetMachine directly. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10636 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/InstrSelection.h | 8 +--- include/llvm/CodeGen/IntrinsicLowering.h | 2 + include/llvm/IntrinsicLowering.h | 2 + include/llvm/Target/TargetMachine.h | 20 +++++---- lib/CodeGen/InstrSelection/InstrSelection.cpp | 12 ++---- lib/CodeGen/IntrinsicLowering.cpp | 1 - lib/ExecutionEngine/Interpreter/Execution.cpp | 1 - .../SparcV9/InstrSelection/InstrSelection.cpp | 12 ++---- lib/Target/SparcV9/SparcV9JITInfo.h | 4 +- lib/Target/SparcV9/SparcV9TargetMachine.cpp | 13 ++---- lib/Target/SparcV9/SparcV9TargetMachine.h | 3 -- lib/Target/TargetMachine.cpp | 42 +++++++++++-------- lib/Target/X86/InstSelectPattern.cpp | 3 +- lib/Target/X86/InstSelectSimple.cpp | 12 ++---- lib/Target/X86/X86.h | 6 +-- lib/Target/X86/X86ISelPattern.cpp | 3 +- lib/Target/X86/X86ISelSimple.cpp | 12 ++---- lib/Target/X86/X86JITInfo.h | 5 +-- lib/Target/X86/X86TargetMachine.cpp | 19 ++++----- lib/Target/X86/X86TargetMachine.h | 2 - lib/VMCore/IntrinsicLowering.cpp | 1 - 21 files changed, 76 insertions(+), 107 deletions(-) diff --git a/include/llvm/CodeGen/InstrSelection.h b/include/llvm/CodeGen/InstrSelection.h index 294bd8eb1f5..5fa1ab1782c 100644 --- a/include/llvm/CodeGen/InstrSelection.h +++ b/include/llvm/CodeGen/InstrSelection.h @@ -22,7 +22,6 @@ class Function; class FunctionPass; class InstrForest; class InstructionNode; -class IntrinsicLowering; class MachineCodeForInstruction; class MachineInstr; class TargetMachine; @@ -40,8 +39,6 @@ extern void GetInstructionsByRule (InstructionNode* subtreeRoot, extern bool ThisIsAChainRule (int eruleno); -//************************ Exported Functions ******************************/ - //--------------------------------------------------------------------------- // Function: createInstructionSelectionPass @@ -51,12 +48,9 @@ extern bool ThisIsAChainRule (int eruleno); // Return a pass that performs machine dependent instruction selection. //--------------------------------------------------------------------------- -FunctionPass *createInstructionSelectionPass(TargetMachine &Target, - IntrinsicLowering &IL); +FunctionPass *createInstructionSelectionPass(TargetMachine &Target); -//************************ Exported Data Types *****************************/ - //--------------------------------------------------------------------------- // class TmpInstruction diff --git a/include/llvm/CodeGen/IntrinsicLowering.h b/include/llvm/CodeGen/IntrinsicLowering.h index 7f0cd81ca6e..19ccb61b47d 100644 --- a/include/llvm/CodeGen/IntrinsicLowering.h +++ b/include/llvm/CodeGen/IntrinsicLowering.h @@ -33,6 +33,8 @@ #ifndef LLVM_INTRINSICLOWERING_H #define LLVM_INTRINSICLOWERING_H +#include "llvm/Intrinsics.h" + namespace llvm { class CallInst; diff --git a/include/llvm/IntrinsicLowering.h b/include/llvm/IntrinsicLowering.h index 7f0cd81ca6e..19ccb61b47d 100644 --- a/include/llvm/IntrinsicLowering.h +++ b/include/llvm/IntrinsicLowering.h @@ -33,6 +33,8 @@ #ifndef LLVM_INTRINSICLOWERING_H #define LLVM_INTRINSICLOWERING_H +#include "llvm/Intrinsics.h" + namespace llvm { class CallInst; diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h index e326a2b68f5..a653d6a47f2 100644 --- a/include/llvm/Target/TargetMachine.h +++ b/include/llvm/Target/TargetMachine.h @@ -31,6 +31,7 @@ class MRegisterInfo; class FunctionPassManager; class PassManager; class Pass; +class IntrinsicLowering; //===----------------------------------------------------------------------===// /// @@ -40,24 +41,27 @@ class Pass; /// class TargetMachine { const std::string Name; - const TargetData DataLayout; // Calculates type size & alignment + const TargetData DataLayout; // Calculates type size & alignment + IntrinsicLowering *IL; // Specifies how to lower intrinsic calls TargetMachine(const TargetMachine&); // DO NOT IMPLEMENT void operator=(const TargetMachine&); // DO NOT IMPLEMENT -protected: - TargetMachine(const std::string &name, // Can only create subclasses... +protected: // Can only create subclasses... + TargetMachine(const std::string &name, IntrinsicLowering *IL, bool LittleEndian = false, unsigned char PtrSize = 8, unsigned char PtrAl = 8, unsigned char DoubleAl = 8, unsigned char FloatAl = 4, unsigned char LongAl = 8, unsigned char IntAl = 4, - unsigned char ShortAl = 2, unsigned char ByteAl = 1) - : Name(name), DataLayout(name, LittleEndian, - PtrSize, PtrAl, DoubleAl, FloatAl, LongAl, - IntAl, ShortAl, ByteAl) {} + unsigned char ShortAl = 2, unsigned char ByteAl = 1); public: - virtual ~TargetMachine() {} + virtual ~TargetMachine(); const std::string &getName() const { return Name; } + + // getIntrinsicLowering - This method returns a reference to an + // IntrinsicLowering instance which should be used by the code generator to + // lower unknown intrinsic functions to the equivalent LLVM expansion. + IntrinsicLowering &getIntrinsicLowering() const { return *IL; } // Interfaces to the major aspects of target machine information: // -- Instruction opcode and operand information diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp index f1fcc8fdc87..5d9d0a355b1 100644 --- a/lib/CodeGen/InstrSelection/InstrSelection.cpp +++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp @@ -16,7 +16,6 @@ #include "llvm/CodeGen/InstrSelection.h" #include "llvm/Function.h" -#include "llvm/Intrinsics.h" #include "llvm/IntrinsicLowering.h" #include "llvm/iPHINode.h" #include "llvm/iOther.h" @@ -68,7 +67,6 @@ namespace { // class InstructionSelection : public FunctionPass { TargetMachine &Target; - IntrinsicLowering &IL; void InsertCodeForPhis(Function &F); void InsertPhiElimInstructions(BasicBlock *BB, const std::vector& CpVec); @@ -76,8 +74,7 @@ namespace { void PostprocessMachineCodeForTree(InstructionNode* instrNode, int ruleForNode, short* nts); public: - InstructionSelection(TargetMachine &TM, IntrinsicLowering &il) - : Target(TM), IL(il) {} + InstructionSelection(TargetMachine &TM) : Target(TM) {} virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesCFG(); @@ -145,7 +142,7 @@ bool InstructionSelection::runOnFunction(Function &F) { default: // All other intrinsic calls we must lower. Instruction *Before = CI->getPrev(); - IL.LowerIntrinsicCall(CI); + Target.getIntrinsicLowering().LowerIntrinsicCall(CI); if (Before) { // Move iterator to instruction after call I = Before; ++I; } else { @@ -415,7 +412,6 @@ InstructionSelection::PostprocessMachineCodeForTree(InstructionNode* instrNode, // createInstructionSelectionPass - Public entrypoint for instruction selection // and this file as a whole... // -FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &T, - IntrinsicLowering &IL) { - return new InstructionSelection(T, IL); +FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &TM) { + return new InstructionSelection(TM); } diff --git a/lib/CodeGen/IntrinsicLowering.cpp b/lib/CodeGen/IntrinsicLowering.cpp index 31a904351d2..4815be9f280 100644 --- a/lib/CodeGen/IntrinsicLowering.cpp +++ b/lib/CodeGen/IntrinsicLowering.cpp @@ -13,7 +13,6 @@ #include "llvm/IntrinsicLowering.h" #include "llvm/Constant.h" -#include "llvm/Intrinsics.h" #include "llvm/Module.h" #include "llvm/Type.h" #include "llvm/iOther.h" diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index bec4b7b9056..eec647a1849 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -17,7 +17,6 @@ #include "llvm/DerivedTypes.h" #include "llvm/Instructions.h" #include "llvm/IntrinsicLowering.h" -#include "llvm/Intrinsics.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "Support/Statistic.h" #include "Support/Debug.h" diff --git a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp index f1fcc8fdc87..5d9d0a355b1 100644 --- a/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp +++ b/lib/Target/SparcV9/InstrSelection/InstrSelection.cpp @@ -16,7 +16,6 @@ #include "llvm/CodeGen/InstrSelection.h" #include "llvm/Function.h" -#include "llvm/Intrinsics.h" #include "llvm/IntrinsicLowering.h" #include "llvm/iPHINode.h" #include "llvm/iOther.h" @@ -68,7 +67,6 @@ namespace { // class InstructionSelection : public FunctionPass { TargetMachine &Target; - IntrinsicLowering &IL; void InsertCodeForPhis(Function &F); void InsertPhiElimInstructions(BasicBlock *BB, const std::vector& CpVec); @@ -76,8 +74,7 @@ namespace { void PostprocessMachineCodeForTree(InstructionNode* instrNode, int ruleForNode, short* nts); public: - InstructionSelection(TargetMachine &TM, IntrinsicLowering &il) - : Target(TM), IL(il) {} + InstructionSelection(TargetMachine &TM) : Target(TM) {} virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesCFG(); @@ -145,7 +142,7 @@ bool InstructionSelection::runOnFunction(Function &F) { default: // All other intrinsic calls we must lower. Instruction *Before = CI->getPrev(); - IL.LowerIntrinsicCall(CI); + Target.getIntrinsicLowering().LowerIntrinsicCall(CI); if (Before) { // Move iterator to instruction after call I = Before; ++I; } else { @@ -415,7 +412,6 @@ InstructionSelection::PostprocessMachineCodeForTree(InstructionNode* instrNode, // createInstructionSelectionPass - Public entrypoint for instruction selection // and this file as a whole... // -FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &T, - IntrinsicLowering &IL) { - return new InstructionSelection(T, IL); +FunctionPass *llvm::createInstructionSelectionPass(TargetMachine &TM) { + return new InstructionSelection(TM); } diff --git a/lib/Target/SparcV9/SparcV9JITInfo.h b/lib/Target/SparcV9/SparcV9JITInfo.h index d1000fe8da9..b667c5599e4 100644 --- a/lib/Target/SparcV9/SparcV9JITInfo.h +++ b/lib/Target/SparcV9/SparcV9JITInfo.h @@ -18,13 +18,11 @@ namespace llvm { class TargetMachine; - class IntrinsicLowering; class SparcJITInfo : public TargetJITInfo { TargetMachine &TM; - IntrinsicLowering &IL; public: - SparcJITInfo(TargetMachine &tm, IntrinsicLowering &il) : TM(tm), IL(il) {} + SparcJITInfo(TargetMachine &tm) : TM(tm) {} /// addPassesToJITCompile - Add passes to the specified pass manager to /// implement a fast dynamic compiler for this target. Return true if this diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.cpp b/lib/Target/SparcV9/SparcV9TargetMachine.cpp index f5ac9a5babb..03de7397c3a 100644 --- a/lib/Target/SparcV9/SparcV9TargetMachine.cpp +++ b/lib/Target/SparcV9/SparcV9TargetMachine.cpp @@ -116,17 +116,12 @@ FunctionPass *llvm::createSparcMachineCodeDestructionPass() { SparcTargetMachine::SparcTargetMachine(IntrinsicLowering *il) - : TargetMachine("UltraSparc-Native", false), - IL(il ? il : new DefaultIntrinsicLowering()), + : TargetMachine("UltraSparc-Native", il, false), schedInfo(*this), regInfo(*this), frameInfo(*this), cacheInfo(*this), - jitInfo(*this, *IL) { -} - -SparcTargetMachine::~SparcTargetMachine() { - delete IL; + jitInfo(*this) { } // addPassesToEmitAssembly - This method controls the entire code generation @@ -171,7 +166,7 @@ SparcTargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) PM.add(new PrintFunctionPass("Input code to instr. selection:\n", &std::cerr)); - PM.add(createInstructionSelectionPass(*this, *IL)); + PM.add(createInstructionSelectionPass(*this)); if (!DisableSched) PM.add(createInstructionSchedulingWithSSAPass(*this)); @@ -238,7 +233,7 @@ void SparcJITInfo::addPassesToJITCompile(FunctionPassManager &PM) { //PM.add(createLICMPass()); //PM.add(createGCSEPass()); - PM.add(createInstructionSelectionPass(TM, IL)); + PM.add(createInstructionSelectionPass(TM)); PM.add(getRegisterAllocator(TM)); PM.add(createPrologEpilogInsertionPass()); diff --git a/lib/Target/SparcV9/SparcV9TargetMachine.h b/lib/Target/SparcV9/SparcV9TargetMachine.h index 4ebd3dc1698..be50174de72 100644 --- a/lib/Target/SparcV9/SparcV9TargetMachine.h +++ b/lib/Target/SparcV9/SparcV9TargetMachine.h @@ -24,10 +24,8 @@ namespace llvm { class PassManager; - class IntrinsicLowering; class SparcTargetMachine : public TargetMachine { - IntrinsicLowering *IL; SparcInstrInfo instrInfo; SparcSchedInfo schedInfo; SparcRegInfo regInfo; @@ -36,7 +34,6 @@ class SparcTargetMachine : public TargetMachine { SparcJITInfo jitInfo; public: SparcTargetMachine(IntrinsicLowering *IL); - ~SparcTargetMachine(); virtual const TargetInstrInfo &getInstrInfo() const { return instrInfo; } virtual const TargetSchedInfo &getSchedInfo() const { return schedInfo; } diff --git a/lib/Target/TargetMachine.cpp b/lib/Target/TargetMachine.cpp index e7630b4ab34..51c1222ab68 100644 --- a/lib/Target/TargetMachine.cpp +++ b/lib/Target/TargetMachine.cpp @@ -15,20 +15,33 @@ #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetCacheInfo.h" #include "llvm/Type.h" - -namespace llvm { +#include "llvm/IntrinsicLowering.h" +using namespace llvm; //--------------------------------------------------------------------------- -// class TargetMachine -// -// Purpose: -// Machine description. -// -//--------------------------------------------------------------------------- +// TargetMachine Class +// +TargetMachine::TargetMachine(const std::string &name, IntrinsicLowering *il, + bool LittleEndian, + unsigned char PtrSize, unsigned char PtrAl, + unsigned char DoubleAl, unsigned char FloatAl, + unsigned char LongAl, unsigned char IntAl, + unsigned char ShortAl, unsigned char ByteAl) + : Name(name), DataLayout(name, LittleEndian, + PtrSize, PtrAl, DoubleAl, FloatAl, LongAl, + IntAl, ShortAl, ByteAl) { + IL = il ? il : new DefaultIntrinsicLowering(); +} + + + +TargetMachine::~TargetMachine() { + delete IL; +} + + -// function TargetMachine::findOptimalStorageSize -// unsigned TargetMachine::findOptimalStorageSize(const Type *Ty) const { // All integer types smaller than ints promote to 4 byte integers. if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) @@ -39,11 +52,8 @@ unsigned TargetMachine::findOptimalStorageSize(const Type *Ty) const { //--------------------------------------------------------------------------- -// class TargetCacheInfo -// -// Purpose: -// Describes properties of the target cache architecture. -//--------------------------------------------------------------------------- +// TargetCacheInfo Class +// void TargetCacheInfo::Initialize() { numLevels = 2; @@ -51,5 +61,3 @@ void TargetCacheInfo::Initialize() { cacheSizes.push_back(1 << 15); cacheSizes.push_back(1 << 20); cacheAssoc.push_back(1); cacheAssoc.push_back(4); } - -} // End llvm namespace diff --git a/lib/Target/X86/InstSelectPattern.cpp b/lib/Target/X86/InstSelectPattern.cpp index a09d104d418..6b848b00ea2 100644 --- a/lib/Target/X86/InstSelectPattern.cpp +++ b/lib/Target/X86/InstSelectPattern.cpp @@ -119,7 +119,6 @@ void ISel::expandCall(SelectionDAG &SD, CallInst &CI) { /// into a machine code representation using pattern matching and a machine /// description file. /// -FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM, - IntrinsicLowering &IL) { +FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM) { return new ISel(TM); } diff --git a/lib/Target/X86/InstSelectSimple.cpp b/lib/Target/X86/InstSelectSimple.cpp index 1029fc669b9..0cd24813e95 100644 --- a/lib/Target/X86/InstSelectSimple.cpp +++ b/lib/Target/X86/InstSelectSimple.cpp @@ -18,7 +18,6 @@ #include "llvm/DerivedTypes.h" #include "llvm/Function.h" #include "llvm/Instructions.h" -#include "llvm/Intrinsics.h" #include "llvm/IntrinsicLowering.h" #include "llvm/Pass.h" #include "llvm/CodeGen/MachineConstantPool.h" @@ -59,7 +58,6 @@ inline static MachineInstrBuilder BMI(MachineBasicBlock *MBB, namespace { struct ISel : public FunctionPass, InstVisitor { TargetMachine &TM; - IntrinsicLowering &IL; MachineFunction *F; // The function we are compiling into MachineBasicBlock *BB; // The current MBB we are compiling int VarArgsFrameIndex; // FrameIndex for start of varargs area @@ -69,8 +67,7 @@ namespace { // MBBMap - Mapping between LLVM BB -> Machine BB std::map MBBMap; - ISel(TargetMachine &tm, IntrinsicLowering &il) - : TM(tm), IL(il), F(0), BB(0) {} + ISel(TargetMachine &tm) : TM(tm), F(0), BB(0) {} /// runOnFunction - Top level implementation of instruction selection for /// the entire function. @@ -1116,7 +1113,7 @@ void ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) { default: // All other intrinsic calls we must lower. Instruction *Before = CI->getPrev(); - IL.LowerIntrinsicCall(CI); + TM.getIntrinsicLowering().LowerIntrinsicCall(CI); if (Before) { // Move iterator to instruction after call I = Before; ++I; } else { @@ -2196,7 +2193,6 @@ void ISel::visitFreeInst(FreeInst &I) { /// into a machine code representation is a very simple peep-hole fashion. The /// generated code sucks but the implementation is nice and simple. /// -FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM, - IntrinsicLowering &IL) { - return new ISel(TM, IL); +FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM) { + return new ISel(TM); } diff --git a/lib/Target/X86/X86.h b/lib/Target/X86/X86.h index 65c13bf001f..54e2861a5f6 100644 --- a/lib/Target/X86/X86.h +++ b/lib/Target/X86/X86.h @@ -27,15 +27,13 @@ class IntrinsicLowering; /// into a machine code representation in a very simple peep-hole fashion. The /// generated code sucks but the implementation is nice and simple. /// -FunctionPass *createX86SimpleInstructionSelector(TargetMachine &TM, - IntrinsicLowering &IL); +FunctionPass *createX86SimpleInstructionSelector(TargetMachine &TM); /// createX86PatternInstructionSelector - This pass converts an LLVM function /// into a machine code representation using pattern matching and a machine /// description file. /// -FunctionPass *createX86PatternInstructionSelector(TargetMachine &TM, - IntrinsicLowering &IL); +FunctionPass *createX86PatternInstructionSelector(TargetMachine &TM); /// createX86SSAPeepholeOptimizerPass - Create a pass to perform SSA-based X86 /// specific peephole optimizations. diff --git a/lib/Target/X86/X86ISelPattern.cpp b/lib/Target/X86/X86ISelPattern.cpp index a09d104d418..6b848b00ea2 100644 --- a/lib/Target/X86/X86ISelPattern.cpp +++ b/lib/Target/X86/X86ISelPattern.cpp @@ -119,7 +119,6 @@ void ISel::expandCall(SelectionDAG &SD, CallInst &CI) { /// into a machine code representation using pattern matching and a machine /// description file. /// -FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM, - IntrinsicLowering &IL) { +FunctionPass *llvm::createX86PatternInstructionSelector(TargetMachine &TM) { return new ISel(TM); } diff --git a/lib/Target/X86/X86ISelSimple.cpp b/lib/Target/X86/X86ISelSimple.cpp index 1029fc669b9..0cd24813e95 100644 --- a/lib/Target/X86/X86ISelSimple.cpp +++ b/lib/Target/X86/X86ISelSimple.cpp @@ -18,7 +18,6 @@ #include "llvm/DerivedTypes.h" #include "llvm/Function.h" #include "llvm/Instructions.h" -#include "llvm/Intrinsics.h" #include "llvm/IntrinsicLowering.h" #include "llvm/Pass.h" #include "llvm/CodeGen/MachineConstantPool.h" @@ -59,7 +58,6 @@ inline static MachineInstrBuilder BMI(MachineBasicBlock *MBB, namespace { struct ISel : public FunctionPass, InstVisitor { TargetMachine &TM; - IntrinsicLowering &IL; MachineFunction *F; // The function we are compiling into MachineBasicBlock *BB; // The current MBB we are compiling int VarArgsFrameIndex; // FrameIndex for start of varargs area @@ -69,8 +67,7 @@ namespace { // MBBMap - Mapping between LLVM BB -> Machine BB std::map MBBMap; - ISel(TargetMachine &tm, IntrinsicLowering &il) - : TM(tm), IL(il), F(0), BB(0) {} + ISel(TargetMachine &tm) : TM(tm), F(0), BB(0) {} /// runOnFunction - Top level implementation of instruction selection for /// the entire function. @@ -1116,7 +1113,7 @@ void ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) { default: // All other intrinsic calls we must lower. Instruction *Before = CI->getPrev(); - IL.LowerIntrinsicCall(CI); + TM.getIntrinsicLowering().LowerIntrinsicCall(CI); if (Before) { // Move iterator to instruction after call I = Before; ++I; } else { @@ -2196,7 +2193,6 @@ void ISel::visitFreeInst(FreeInst &I) { /// into a machine code representation is a very simple peep-hole fashion. The /// generated code sucks but the implementation is nice and simple. /// -FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM, - IntrinsicLowering &IL) { - return new ISel(TM, IL); +FunctionPass *llvm::createX86SimpleInstructionSelector(TargetMachine &TM) { + return new ISel(TM); } diff --git a/lib/Target/X86/X86JITInfo.h b/lib/Target/X86/X86JITInfo.h index 0ebb4c5208e..75efb19a521 100644 --- a/lib/Target/X86/X86JITInfo.h +++ b/lib/Target/X86/X86JITInfo.h @@ -22,9 +22,8 @@ namespace llvm { class X86JITInfo : public TargetJITInfo { TargetMachine &TM; - IntrinsicLowering &IL; public: - X86JITInfo(TargetMachine &tm, IntrinsicLowering &il) : TM(tm), IL(il) {} + X86JITInfo(TargetMachine &tm) : TM(tm) {} /// addPassesToJITCompile - Add passes to the specified pass manager to /// implement a fast dynamic compiler for this target. Return true if this @@ -37,7 +36,7 @@ namespace llvm { /// overwriting OLD with a branch to NEW. This is used for self-modifying /// code. /// - virtual void replaceMachineCodeForFunction (void *Old, void *New); + virtual void replaceMachineCodeForFunction(void *Old, void *New); /// getJITStubForFunction - Create or return a stub for the specified /// function. This stub acts just like the specified function, except that diff --git a/lib/Target/X86/X86TargetMachine.cpp b/lib/Target/X86/X86TargetMachine.cpp index e4d1ecb9b14..879ad503117 100644 --- a/lib/Target/X86/X86TargetMachine.cpp +++ b/lib/Target/X86/X86TargetMachine.cpp @@ -45,15 +45,10 @@ TargetMachine *llvm::allocateX86TargetMachine(const Module &M, /// X86TargetMachine ctor - Create an ILP32 architecture model /// -X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *il) - : TargetMachine("X86", true, 4, 4, 4, 4, 4), - IL(il ? il : new DefaultIntrinsicLowering()), +X86TargetMachine::X86TargetMachine(const Module &M, IntrinsicLowering *IL) + : TargetMachine("X86", IL, true, 4, 4, 4, 4, 4), FrameInfo(TargetFrameInfo::StackGrowsDown, 8/*16 for SSE*/, 4), - JITInfo(*this, *IL) { -} - -X86TargetMachine::~X86TargetMachine() { - delete IL; + JITInfo(*this) { } @@ -72,9 +67,9 @@ bool X86TargetMachine::addPassesToEmitAssembly(PassManager &PM, PM.add(createCFGSimplificationPass()); if (NoPatternISel) - PM.add(createX86SimpleInstructionSelector(*this, *IL)); + PM.add(createX86SimpleInstructionSelector(*this)); else - PM.add(createX86PatternInstructionSelector(*this, *IL)); + PM.add(createX86PatternInstructionSelector(*this)); // Run optional SSA-based machine code optimizations next... if (!NoSSAPeephole) @@ -127,9 +122,9 @@ void X86JITInfo::addPassesToJITCompile(FunctionPassManager &PM) { PM.add(createCFGSimplificationPass()); if (NoPatternISel) - PM.add(createX86SimpleInstructionSelector(TM, IL)); + PM.add(createX86SimpleInstructionSelector(TM)); else - PM.add(createX86PatternInstructionSelector(TM, IL)); + PM.add(createX86PatternInstructionSelector(TM)); // Run optional SSA-based machine code optimizations next... if (!NoSSAPeephole) diff --git a/lib/Target/X86/X86TargetMachine.h b/lib/Target/X86/X86TargetMachine.h index 6cd8ac1ab3d..be8d8879a12 100644 --- a/lib/Target/X86/X86TargetMachine.h +++ b/lib/Target/X86/X86TargetMachine.h @@ -24,13 +24,11 @@ namespace llvm { class IntrinsicLowering; class X86TargetMachine : public TargetMachine { - IntrinsicLowering *IL; X86InstrInfo InstrInfo; TargetFrameInfo FrameInfo; X86JITInfo JITInfo; public: X86TargetMachine(const Module &M, IntrinsicLowering *IL); - ~X86TargetMachine(); virtual const X86InstrInfo &getInstrInfo() const { return InstrInfo; } virtual const TargetFrameInfo &getFrameInfo() const { return FrameInfo; } diff --git a/lib/VMCore/IntrinsicLowering.cpp b/lib/VMCore/IntrinsicLowering.cpp index 31a904351d2..4815be9f280 100644 --- a/lib/VMCore/IntrinsicLowering.cpp +++ b/lib/VMCore/IntrinsicLowering.cpp @@ -13,7 +13,6 @@ #include "llvm/IntrinsicLowering.h" #include "llvm/Constant.h" -#include "llvm/Intrinsics.h" #include "llvm/Module.h" #include "llvm/Type.h" #include "llvm/iOther.h"