remove the intrinsiclowering hook

llvm-svn: 26970

llvm/include/llvm/ExecutionEngine/ExecutionEngine.h

@@ -32,8 +32,6 @@ class Module;
 class ModuleProvider;
 class TargetData;
 class Type;
-class IntrinsicLowering;
-
 
 class ExecutionEngineState {
 private:
@@ -76,7 +74,7 @@ protected:
   // To avoid having libexecutionengine depend on the JIT and interpreter
   // libraries, the JIT and Interpreter set these functions to ctor pointers
   // at startup time if they are linked in.
-  typedef ExecutionEngine *(*EECtorFn)(ModuleProvider*, IntrinsicLowering*);
+  typedef ExecutionEngine *(*EECtorFn)(ModuleProvider*);
   static EECtorFn JITCtor, InterpCtor;
     
 public:
@@ -93,10 +91,9 @@ public:
   const TargetData &getTargetData() const { return *TD; }
 
   /// create - This is the factory method for creating an execution engine which
-  /// is appropriate for the current machine.  If specified, the
-  /// IntrinsicLowering implementation should be allocated on the heap.
-  static ExecutionEngine *create(ModuleProvider *MP, bool ForceInterpreter,
-                                 IntrinsicLowering *IL = 0);
+  /// is appropriate for the current machine.
+  static ExecutionEngine *create(ModuleProvider *MP,
+                                 bool ForceInterpreter = false);
 
   /// runFunction - Execute the specified function with the specified arguments,
   /// and return the result.

llvm/lib/ExecutionEngine/ExecutionEngine.cpp

@@ -160,24 +160,22 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn,
 /// NULL is returned.
 ///
 ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP,
-                                         bool ForceInterpreter,
-                                         IntrinsicLowering *IL) {
+                                         bool ForceInterpreter) {
   ExecutionEngine *EE = 0;
 
   // Unless the interpreter was explicitly selected, try making a JIT.
   if (!ForceInterpreter && JITCtor)
-    EE = JITCtor(MP, IL);
+    EE = JITCtor(MP);
 
   // If we can't make a JIT, make an interpreter instead.
   if (EE == 0 && InterpCtor)
-    EE = InterpCtor(MP, IL);
+    EE = InterpCtor(MP);
 
-  if (EE == 0)
-    delete IL;
-  else
+  if (EE) {
     // Make sure we can resolve symbols in the program as well. The zero arg
     // to the function tells DynamicLibrary to load the program, not a library.
     sys::DynamicLibrary::LoadLibraryPermanently(0);
+  }
 
   return EE;
 }

llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp

@@ -26,8 +26,7 @@ static struct RegisterInterp {
 
 /// create - Create a new interpreter object.  This can never fail.
 ///
-ExecutionEngine *Interpreter::create(ModuleProvider *MP,
-                                     IntrinsicLowering *IL) {
+ExecutionEngine *Interpreter::create(ModuleProvider *MP) {
   Module *M;
   try {
     M = MP->materializeModule();
@@ -55,17 +54,16 @@ ExecutionEngine *Interpreter::create(ModuleProvider *MP,
     break;
   }
 
-  return new Interpreter(M, isLittleEndian, isLongPointer, IL);
+  return new Interpreter(M, isLittleEndian, isLongPointer);
 }
 
 //===----------------------------------------------------------------------===//
 // Interpreter ctor - Initialize stuff
 //
-Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
-                         IntrinsicLowering *il)
+Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer)
   : ExecutionEngine(M),
     TD("lli", isLittleEndian, isLongPointer ? 8 : 4, isLongPointer ? 8 : 4,
-       isLongPointer ? 8 : 4), IL(il) {
+       isLongPointer ? 8 : 4) {
 
   memset(&ExitValue, 0, sizeof(ExitValue));
   setTargetData(TD);
@@ -74,7 +72,7 @@ Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
   initializeExternalFunctions();
   emitGlobals();
 
-  if (IL == 0) IL = new DefaultIntrinsicLowering();
+  IL = new DefaultIntrinsicLowering();
 }
 
 Interpreter::~Interpreter() {

llvm/lib/ExecutionEngine/Interpreter/Interpreter.h

@@ -25,6 +25,7 @@
 
 namespace llvm {
 
+class IntrinsicLowering;
 struct FunctionInfo;
 template<typename T> class generic_gep_type_iterator;
 class ConstantExpr;
@@ -93,8 +94,7 @@ class Interpreter : public ExecutionEngine, public InstVisitor<Interpreter> {
   std::vector<Function*> AtExitHandlers;
 
 public:
-  Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
-              IntrinsicLowering *IL);
+  Interpreter(Module *M, bool isLittleEndian, bool isLongPointer);
   ~Interpreter();
 
   /// runAtExitHandlers - Run any functions registered by the program's calls to
@@ -106,11 +106,9 @@ public:
     InterpCtor = create;
   }
   
-  /// create - Create an interpreter ExecutionEngine. This can never fail.  The
-  /// specified IntrinsicLowering implementation will be deleted when the
-  /// Interpreter execution engine is destroyed.
+  /// create - Create an interpreter ExecutionEngine. This can never fail.
   ///
-  static ExecutionEngine *create(ModuleProvider *M, IntrinsicLowering *IL);
+  static ExecutionEngine *create(ModuleProvider *M);
 
   /// run - Start execution with the specified function and arguments.
   ///

llvm/lib/ExecutionEngine/JIT/JIT.h

@@ -69,11 +69,9 @@ public:
   TargetJITInfo &getJITInfo() const { return TJI; }
 
   /// create - Create an return a new JIT compiler if there is one available
-  /// for the current target.  Otherwise, return null.  If the JIT is created
-  /// successfully, it takes responsibility for deleting the specified
-  /// IntrinsicLowering implementation.
+  /// for the current target.  Otherwise, return null.
   ///
-  static ExecutionEngine *create(ModuleProvider *MP, IntrinsicLowering *IL = 0);
+  static ExecutionEngine *create(ModuleProvider *MP);
 
   /// run - Start execution with the specified function and arguments.
   ///

llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp

@@ -39,7 +39,7 @@ MAttrs("mattr",
 /// create - Create an return a new JIT compiler if there is one available
 /// for the current target.  Otherwise, return null.
 ///
-ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
+ExecutionEngine *JIT::create(ModuleProvider *MP) {
   if (MArch == 0) {
     std::string Error;
     MArch = TargetMachineRegistry::getClosestTargetForJIT(Error);
@@ -61,7 +61,7 @@ ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
   }
 
   // Allocate a target...
-  TargetMachine *Target = MArch->CtorFn(*MP->getModule(), IL, FeaturesStr);
+  TargetMachine *Target = MArch->CtorFn(*MP->getModule(), 0, FeaturesStr);
   assert(Target && "Could not allocate target machine!");
 
   // If the target supports JIT code generation, return a new JIT now.