First patch in the direction of splitting MachineCodeEmitter in two subclasses:

JITCodeEmitter and ObjectCodeEmitter. No functional changes yet. Patch by Aaron Gray



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

2 files changed, 66 insertions, 8 deletions

diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h
index 3f48da9f40..9545689cb7 100644
--- a/include/llvm/Target/TargetJITInfo.h
+++ b/include/llvm/Target/TargetJITInfo.h
@@ -23,7 +23,7 @@
 namespace llvm {
   class Function;
   class GlobalValue;
-  class MachineCodeEmitter;
+  class JITCodeEmitter;
   class MachineRelocation;
 
   /// TargetJITInfo - Target specific information required by the Just-In-Time
@@ -39,29 +39,29 @@ namespace llvm {
     ///
     virtual void replaceMachineCodeForFunction(void *Old, void *New) = 0;
 
-    /// emitGlobalValueIndirectSym - Use the specified MachineCodeEmitter object
+    /// emitGlobalValueIndirectSym - Use the specified JITCodeEmitter object
     /// to emit an indirect symbol which contains the address of the specified
     /// ptr.
     virtual void *emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr,
-                                             MachineCodeEmitter &MCE) {
+                                             JITCodeEmitter &JCE) {
       assert(0 && "This target doesn't implement emitGlobalValueIndirectSym!");
       return 0;
     }
 
-    /// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a
+    /// emitFunctionStub - Use the specified JITCodeEmitter object to emit a
     /// small native function that simply calls the function at the specified
     /// address.  Return the address of the resultant function.
     virtual void *emitFunctionStub(const Function* F, void *Fn,
-                                   MachineCodeEmitter &MCE) {
+                                   JITCodeEmitter &JCE) {
       assert(0 && "This target doesn't implement emitFunctionStub!");
       return 0;
     }
     
-    /// emitFunctionStubAtAddr - Use the specified MachineCodeEmitter object to
+    /// emitFunctionStubAtAddr - Use the specified JITCodeEmitter object to
     /// emit a small native function that simply calls Fn. Emit the stub into
     /// the supplied buffer.
     virtual void emitFunctionStubAtAddr(const Function* F, void *Fn,
-                                        void *Buffer, MachineCodeEmitter &MCE) {
+                                        void *Buffer, JITCodeEmitter &JCE) {
       assert(0 && "This target doesn't implement emitFunctionStubAtAddr!");
     }
 
@@ -125,7 +125,7 @@ namespace llvm {
 
     /// allocateSeparateGVMemory - If true, globals should be placed in
     /// separately allocated heap memory rather than in the same
-    /// code memory allocated by MachineCodeEmitter.
+    /// code memory allocated by JITCodeEmitter.
     virtual bool allocateSeparateGVMemory() const { return false; }
   protected:
     bool useGOT;
diff --git a/include/llvm/Target/TargetMachine.h b/include/llvm/Target/TargetMachine.h
index 405f22eeb4..bdcc4eff67 100644
--- a/include/llvm/Target/TargetMachine.h
+++ b/include/llvm/Target/TargetMachine.h
@@ -28,6 +28,7 @@ class TargetJITInfo;
 class TargetLowering;
 class TargetFrameInfo;
 class MachineCodeEmitter;
+class JITCodeEmitter;
 class TargetRegisterInfo;
 class Module;
 class PassManagerBase;
@@ -236,6 +237,16 @@ public:
     return true;
   }
  
+  /// addPassesToEmitFileFinish - If the passes to emit the specified file had
+  /// to be split up (e.g., to add an object writer pass), this method can be
+  /// used to finish up adding passes to emit the file, if necessary.
+  ///
+  virtual bool addPassesToEmitFileFinish(PassManagerBase &,
+                                         JITCodeEmitter *,
+                                         CodeGenOpt::Level) {
+    return true;
+  }
+ 
   /// addPassesToEmitMachineCode - Add passes to the specified pass manager to
   /// get machine code emitted.  This uses a MachineCodeEmitter object to handle
   /// actually outputting the machine code and resolving things like the address
@@ -248,6 +259,18 @@ public:
     return true;
   }
 
+  /// addPassesToEmitMachineCode - Add passes to the specified pass manager to
+  /// get machine code emitted.  This uses a MachineCodeEmitter object to handle
+  /// actually outputting the machine code and resolving things like the address
+  /// of functions.  This method returns true if machine code emission is
+  /// not supported.
+  ///
+  virtual bool addPassesToEmitMachineCode(PassManagerBase &,
+                                          JITCodeEmitter &,
+                                          CodeGenOpt::Level) {
+    return true;
+  }
+
   /// addPassesToEmitWholeFile - This method can be implemented by targets that 
   /// require having the entire module at once.  This is not recommended, do not
   /// use this.
@@ -297,6 +320,14 @@ public:
                                          MachineCodeEmitter *MCE,
                                          CodeGenOpt::Level);
  
+  /// addPassesToEmitFileFinish - If the passes to emit the specified file had
+  /// to be split up (e.g., to add an object writer pass), this method can be
+  /// used to finish up adding passes to emit the file, if necessary.
+  ///
+  virtual bool addPassesToEmitFileFinish(PassManagerBase &PM,
+                                         JITCodeEmitter *MCE,
+                                         CodeGenOpt::Level);
+ 
   /// addPassesToEmitMachineCode - Add passes to the specified pass manager to
   /// get machine code emitted.  This uses a MachineCodeEmitter object to handle
   /// actually outputting the machine code and resolving things like the address
@@ -307,6 +338,16 @@ public:
                                           MachineCodeEmitter &MCE,
                                           CodeGenOpt::Level);
   
+  /// addPassesToEmitMachineCode - Add passes to the specified pass manager to
+  /// get machine code emitted.  This uses a MachineCodeEmitter object to handle
+  /// actually outputting the machine code and resolving things like the address
+  /// of functions.  This method returns true if machine code emission is
+  /// not supported.
+  ///
+  virtual bool addPassesToEmitMachineCode(PassManagerBase &PM,
+                                          JITCodeEmitter &MCE,
+                                          CodeGenOpt::Level);
+  
   /// Target-Independent Code Generator Pass Configuration Options.
   
   /// addInstSelector - This method should add any "last minute" LLVM->LLVM
@@ -355,6 +396,14 @@ public:
     return true;
   }
 
+  /// addCodeEmitter - This pass should be overridden by the target to add a
+  /// code emitter, if supported.  If this is not supported, 'true' should be
+  /// returned. If DumpAsm is true, the generated assembly is printed to cerr.
+  virtual bool addCodeEmitter(PassManagerBase &, CodeGenOpt::Level,
+                              bool /*DumpAsm*/, JITCodeEmitter &) {
+    return true;
+  }
+
   /// addSimpleCodeEmitter - This pass should be overridden by the target to add
   /// a code emitter (without setting flags), if supported.  If this is not
   /// supported, 'true' should be returned.  If DumpAsm is true, the generated
@@ -364,6 +413,15 @@ public:
     return true;
   }
 
+  /// addSimpleCodeEmitter - This pass should be overridden by the target to add
+  /// a code emitter (without setting flags), if supported.  If this is not
+  /// supported, 'true' should be returned.  If DumpAsm is true, the generated
+  /// assembly is printed to cerr.
+  virtual bool addSimpleCodeEmitter(PassManagerBase &, CodeGenOpt::Level,
+                                    bool /*DumpAsm*/, JITCodeEmitter &) {
+    return true;
+  }
+
   /// getEnableTailMergeDefault - the default setting for -enable-tail-merge
   /// on this target.  User flag overrides.
   virtual bool getEnableTailMergeDefault() const { return true; }