Rip JIT specific stuff out of TargetMachine, as per PR176

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10542 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 62 insertions, 25 deletions

diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h
new file mode 100644
index 0000000..90fea4e
--- /dev/null
+++ b/include/llvm/Target/TargetJITInfo.h
@@ -0,0 +1,54 @@
+//===- Target/TargetJITInfo.h - Target Information for JIT ------*- C++ -*-===//
+// 
+//                     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.
+// 
+//===----------------------------------------------------------------------===//
+//
+// This file exposes an abstract interface used by the Just-In-Time code
+// generator to perform target-specific activities, such as emitting stubs.  If
+// a TargetMachine supports JIT code generation, it should provide one of these
+// objects through the getJITInfo() method.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TARGET_TARGETJITINFO_H
+#define LLVM_TARGET_TARGETJITINFO_H
+
+namespace llvm {
+  class Function;
+  class FunctionPassManager;
+  class MachineCodeEmitter;
+
+  /// TargetJITInfo - Target specific information required by the Just-In-Time
+  /// code generator.
+  struct TargetJITInfo {
+    virtual ~TargetJITInfo() {}
+    
+    /// addPassesToJITCompile - Add passes to the specified pass manager to
+    /// implement a fast code generator for this target.
+    ///
+    virtual void addPassesToJITCompile(FunctionPassManager &PM) = 0;
+    
+    /// replaceMachineCodeForFunction - Make it so that calling the function
+    /// whose machine code is at OLD turns into a call to NEW, perhaps by
+    /// overwriting OLD with a branch to NEW.  This is used for self-modifying
+    /// code.
+    ///
+    virtual void replaceMachineCodeForFunction (void *Old, void *New) = 0;
+    
+    /// getJITStubForFunction - Create or return a stub for the specified
+    /// function.  This stub acts just like the specified function, except that
+    /// it allows the "address" of the function to be taken without having to
+    /// generate code for it.  Targets do not need to implement this method, but
+    /// doing so will allow for faster startup of the JIT.
+    ///
+    virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE) {
+      return 0;
+    }
+  };
+} // End llvm namespace
+
+#endif
diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h
index 758feb2..e326a2b 100644
--- a/include/llvm/Target/TargetMachine.h
+++ b/include/llvm/Target/TargetMachine.h
@@ -21,6 +21,7 @@ namespace llvm {
 
 class TargetInstrInfo;
 class TargetInstrDescriptor;
+class TargetJITInfo;
 class TargetSchedInfo;
 class TargetRegInfo;
 class TargetFrameInfo;
@@ -79,16 +80,16 @@ public:
   ///
   virtual const MRegisterInfo*          getRegisterInfo() const { return 0; }
 
-  // Data storage information
+  /// getJITInfo - If this target supports a JIT, return information for it,
+  /// otherwise return null.
+  ///
+  virtual TargetJITInfo *getJITInfo() { return 0; }
+
+  // Data storage information.  FIXME, this should be moved out to sparc
+  // specific code.
   // 
   virtual unsigned findOptimalStorageSize(const Type* ty) const;
   
-  /// addPassesToJITCompile - Add passes to the specified pass manager to
-  /// implement a fast dynamic compiler for this target.  Return true if this is
-  /// not supported for this target.
-  ///
-  virtual bool addPassesToJITCompile(FunctionPassManager &PM) { return true; }
-
   /// addPassesToEmitAssembly - Add passes to the specified pass manager to get
   /// assembly langage code emitted.  Typically this will involve several steps
   /// of code generation.  This method should return true if assembly emission
@@ -108,24 +109,6 @@ public:
                                           MachineCodeEmitter &MCE) {
     return true;
   }
-
-  /// replaceMachineCodeForFunction - Make it so that calling the
-  /// function whose machine code is at OLD turns into a call to NEW,
-  /// perhaps by overwriting OLD with a branch to NEW.
-  ///
-  /// FIXME: this is JIT-specific.
-  ///
-  virtual void replaceMachineCodeForFunction (void *Old, void *New) {
-    assert (0 && "Current target cannot replace machine code for functions");
-  }
-
-  /// getJITStubForFunction - Create or return a stub for the specified
-  /// function.  This stub acts just like the specified function, except that it
-  /// allows the "address" of the function to be taken without having to
-  /// generate code for it.
-  virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE) {
-    return 0;
-  }
 };
 
 } // End llvm namespace