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
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index 522a08d..f8ae884 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -19,7 +19,7 @@
 #include "llvm/GlobalVariable.h"
 #include "llvm/Instructions.h"
 #include "llvm/ModuleProvider.h"
-#include "llvm/CodeGen/MachineCodeEmitter.h"
+#include "llvm/CodeGen/JITCodeEmitter.h"
 #include "llvm/ExecutionEngine/GenericValue.h"
 #include "llvm/CodeGen/MachineCodeInfo.h"
 #include "llvm/Target/TargetData.h"
@@ -214,8 +214,8 @@
 
   jitstate = new JITState(MP);
 
-  // Initialize MCE
-  MCE = createEmitter(*this, JMM);
+  // Initialize JCE
+  JCE = createEmitter(*this, JMM);
 
   // Add target data
   MutexGuard locked(lock);
@@ -224,7 +224,7 @@
 
   // Turn the machine code intermediate representation into bytes in memory that
   // may be executed.
-  if (TM.addPassesToEmitMachineCode(PM, *MCE, OptLevel)) {
+  if (TM.addPassesToEmitMachineCode(PM, *JCE, OptLevel)) {
     cerr << "Target does not support machine code emission!\n";
     abort();
   }
@@ -253,7 +253,7 @@
 
 JIT::~JIT() {
   delete jitstate;
-  delete MCE;
+  delete JCE;
   delete &TM;
 }
 
@@ -273,7 +273,7 @@
 
     // Turn the machine code intermediate representation into bytes in memory
     // that may be executed.
-    if (TM.addPassesToEmitMachineCode(PM, *MCE, CodeGenOpt::Default)) {
+    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
       cerr << "Target does not support machine code emission!\n";
       abort();
     }
@@ -306,7 +306,7 @@
     
     // Turn the machine code intermediate representation into bytes in memory
     // that may be executed.
-    if (TM.addPassesToEmitMachineCode(PM, *MCE, CodeGenOpt::Default)) {
+    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
       cerr << "Target does not support machine code emission!\n";
       abort();
     }
@@ -338,7 +338,7 @@
     
     // Turn the machine code intermediate representation into bytes in memory
     // that may be executed.
-    if (TM.addPassesToEmitMachineCode(PM, *MCE, CodeGenOpt::Default)) {
+    if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) {
       cerr << "Target does not support machine code emission!\n";
       abort();
     }
@@ -654,7 +654,7 @@
         Ptr = (char*)Ptr + (MisAligned ? (A-MisAligned) : 0);
       }
     } else {
-      Ptr = MCE->allocateSpace(S, A);
+      Ptr = JCE->allocateSpace(S, A);
     }
     addGlobalMapping(GV, Ptr);
     EmitGlobalVariable(GV);
diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h
index 02955ab..9924d0b 100644
--- a/lib/ExecutionEngine/JIT/JIT.h
+++ b/lib/ExecutionEngine/JIT/JIT.h
@@ -51,7 +51,7 @@
 class JIT : public ExecutionEngine {
   TargetMachine &TM;       // The current target we are compiling to
   TargetJITInfo &TJI;      // The JITInfo for the target we are compiling to
-  MachineCodeEmitter *MCE; // MCE object
+  JITCodeEmitter *JCE; // JCE object
 
   JITState *jitstate;
 
@@ -147,7 +147,7 @@
   void addPendingFunction(Function *F);
   
   /// getCodeEmitter - Return the code emitter this JIT is emitting into.
-  MachineCodeEmitter *getCodeEmitter() const { return MCE; }
+  JITCodeEmitter *getCodeEmitter() const { return JCE; }
   
   static ExecutionEngine *createJIT(ModuleProvider *MP, std::string *Err,
                                     JITMemoryManager *JMM,
@@ -158,7 +158,7 @@
   void runJITOnFunction(Function *F, MachineCodeInfo *MCI = 0);
 
 private:
-  static MachineCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM);
+  static JITCodeEmitter *createEmitter(JIT &J, JITMemoryManager *JMM);
   void registerMachineCodeInfo(MachineCodeInfo *MCI);
   void runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked);
   void updateFunctionStub(Function *F);
diff --git a/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp b/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp
index bb2f92b..e101ef3 100644
--- a/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITDwarfEmitter.cpp
@@ -16,7 +16,7 @@
 #include "JITDwarfEmitter.h"
 #include "llvm/Function.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/CodeGen/MachineCodeEmitter.h"
+#include "llvm/CodeGen/JITCodeEmitter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineLocation.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
@@ -34,7 +34,7 @@
 
 
 unsigned char* JITDwarfEmitter::EmitDwarfTable(MachineFunction& F, 
-                                               MachineCodeEmitter& mce,
+                                               JITCodeEmitter& jce,
                                                unsigned char* StartFunction,
                                                unsigned char* EndFunction) {
   const TargetMachine& TM = F.getTarget();
@@ -42,7 +42,7 @@
   needsIndirectEncoding = TM.getTargetAsmInfo()->getNeedsIndirectEncoding();
   stackGrowthDirection = TM.getFrameInfo()->getStackGrowthDirection();
   RI = TM.getRegisterInfo();
-  MCE = &mce;
+  JCE = &jce;
   
   unsigned char* ExceptionTable = EmitExceptionTable(&F, StartFunction,
                                                      EndFunction);
@@ -81,15 +81,15 @@
     }
     
     intptr_t LabelPtr = 0;
-    if (LabelID) LabelPtr = MCE->getLabelAddress(LabelID);
+    if (LabelID) LabelPtr = JCE->getLabelAddress(LabelID);
 
     const MachineLocation &Dst = Move.getDestination();
     const MachineLocation &Src = Move.getSource();
     
     // Advance row if new location.
     if (BaseLabelPtr && LabelID && (BaseLabelID != LabelID || !IsLocal)) {
-      MCE->emitByte(dwarf::DW_CFA_advance_loc4);
-      MCE->emitInt32(LabelPtr - BaseLabelPtr);
+      JCE->emitByte(dwarf::DW_CFA_advance_loc4);
+      JCE->emitInt32(LabelPtr - BaseLabelPtr);
       
       BaseLabelID = LabelID; 
       BaseLabelPtr = LabelPtr;
@@ -100,23 +100,23 @@
     if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) {
       if (!Src.isReg()) {
         if (Src.getReg() == MachineLocation::VirtualFP) {
-          MCE->emitByte(dwarf::DW_CFA_def_cfa_offset);
+          JCE->emitByte(dwarf::DW_CFA_def_cfa_offset);
         } else {
-          MCE->emitByte(dwarf::DW_CFA_def_cfa);
-          MCE->emitULEB128Bytes(RI->getDwarfRegNum(Src.getReg(), true));
+          JCE->emitByte(dwarf::DW_CFA_def_cfa);
+          JCE->emitULEB128Bytes(RI->getDwarfRegNum(Src.getReg(), true));
         }
         
         int Offset = -Src.getOffset();
         
-        MCE->emitULEB128Bytes(Offset);
+        JCE->emitULEB128Bytes(Offset);
       } else {
         assert(0 && "Machine move no supported yet.");
       }
     } else if (Src.isReg() &&
       Src.getReg() == MachineLocation::VirtualFP) {
       if (Dst.isReg()) {
-        MCE->emitByte(dwarf::DW_CFA_def_cfa_register);
-        MCE->emitULEB128Bytes(RI->getDwarfRegNum(Dst.getReg(), true));
+        JCE->emitByte(dwarf::DW_CFA_def_cfa_register);
+        JCE->emitULEB128Bytes(RI->getDwarfRegNum(Dst.getReg(), true));
       } else {
         assert(0 && "Machine move no supported yet.");
       }
@@ -125,16 +125,16 @@
       int Offset = Dst.getOffset() / stackGrowth;
       
       if (Offset < 0) {
-        MCE->emitByte(dwarf::DW_CFA_offset_extended_sf);
-        MCE->emitULEB128Bytes(Reg);
-        MCE->emitSLEB128Bytes(Offset);
+        JCE->emitByte(dwarf::DW_CFA_offset_extended_sf);
+        JCE->emitULEB128Bytes(Reg);
+        JCE->emitSLEB128Bytes(Offset);
       } else if (Reg < 64) {
-        MCE->emitByte(dwarf::DW_CFA_offset + Reg);
-        MCE->emitULEB128Bytes(Offset);
+        JCE->emitByte(dwarf::DW_CFA_offset + Reg);
+        JCE->emitULEB128Bytes(Offset);
       } else {
-        MCE->emitByte(dwarf::DW_CFA_offset_extended);
-        MCE->emitULEB128Bytes(Reg);
-        MCE->emitULEB128Bytes(Offset);
+        JCE->emitByte(dwarf::DW_CFA_offset_extended);
+        JCE->emitULEB128Bytes(Reg);
+        JCE->emitULEB128Bytes(Offset);
       }
     }
   }
@@ -403,24 +403,24 @@
   unsigned SizeAlign = (4 - TotalSize) & 3;
 
   // Begin the exception table.
-  MCE->emitAlignment(4);
+  JCE->emitAlignment(4);
   for (unsigned i = 0; i != SizeAlign; ++i) {
-    MCE->emitByte(0);
+    JCE->emitByte(0);
     // Asm->EOL("Padding");
   }
   
-  unsigned char* DwarfExceptionTable = (unsigned char*)MCE->getCurrentPCValue();
+  unsigned char* DwarfExceptionTable = (unsigned char*)JCE->getCurrentPCValue();
 
   // Emit the header.
-  MCE->emitByte(dwarf::DW_EH_PE_omit);
+  JCE->emitByte(dwarf::DW_EH_PE_omit);
   // Asm->EOL("LPStart format (DW_EH_PE_omit)");
-  MCE->emitByte(dwarf::DW_EH_PE_absptr);
+  JCE->emitByte(dwarf::DW_EH_PE_absptr);
   // Asm->EOL("TType format (DW_EH_PE_absptr)");
-  MCE->emitULEB128Bytes(TypeOffset);
+  JCE->emitULEB128Bytes(TypeOffset);
   // Asm->EOL("TType base offset");
-  MCE->emitByte(dwarf::DW_EH_PE_udata4);
+  JCE->emitByte(dwarf::DW_EH_PE_udata4);
   // Asm->EOL("Call site format (DW_EH_PE_udata4)");
-  MCE->emitULEB128Bytes(SizeSites);
+  JCE->emitULEB128Bytes(SizeSites);
   // Asm->EOL("Call-site table length");
 
   // Emit the landing pad site information.
@@ -431,32 +431,32 @@
 
     if (!S.BeginLabel) {
       BeginLabelPtr = (intptr_t)StartFunction;
-      MCE->emitInt32(0);
+      JCE->emitInt32(0);
     } else {
-      BeginLabelPtr = MCE->getLabelAddress(S.BeginLabel);
-      MCE->emitInt32(BeginLabelPtr - (intptr_t)StartFunction);
+      BeginLabelPtr = JCE->getLabelAddress(S.BeginLabel);
+      JCE->emitInt32(BeginLabelPtr - (intptr_t)StartFunction);
     }
 
     // Asm->EOL("Region start");
 
     if (!S.EndLabel) {
       EndLabelPtr = (intptr_t)EndFunction;
-      MCE->emitInt32((intptr_t)EndFunction - BeginLabelPtr);
+      JCE->emitInt32((intptr_t)EndFunction - BeginLabelPtr);
     } else {
-      EndLabelPtr = MCE->getLabelAddress(S.EndLabel);
-      MCE->emitInt32(EndLabelPtr - BeginLabelPtr);
+      EndLabelPtr = JCE->getLabelAddress(S.EndLabel);
+      JCE->emitInt32(EndLabelPtr - BeginLabelPtr);
     }
     //Asm->EOL("Region length");
 
     if (!S.PadLabel) {
-      MCE->emitInt32(0);
+      JCE->emitInt32(0);
     } else {
-      unsigned PadLabelPtr = MCE->getLabelAddress(S.PadLabel);
-      MCE->emitInt32(PadLabelPtr - (intptr_t)StartFunction);
+      unsigned PadLabelPtr = JCE->getLabelAddress(S.PadLabel);
+      JCE->emitInt32(PadLabelPtr - (intptr_t)StartFunction);
     }
     // Asm->EOL("Landing pad");
 
-    MCE->emitULEB128Bytes(S.Action);
+    JCE->emitULEB128Bytes(S.Action);
     // Asm->EOL("Action");
   }
 
@@ -464,9 +464,9 @@
   for (unsigned I = 0, N = Actions.size(); I != N; ++I) {
     ActionEntry &Action = Actions[I];
 
-    MCE->emitSLEB128Bytes(Action.ValueForTypeID);
+    JCE->emitSLEB128Bytes(Action.ValueForTypeID);
     //Asm->EOL("TypeInfo index");
-    MCE->emitSLEB128Bytes(Action.NextAction);
+    JCE->emitSLEB128Bytes(Action.NextAction);
     //Asm->EOL("Next action");
   }
 
@@ -476,15 +476,15 @@
     
     if (GV) {
       if (TD->getPointerSize() == sizeof(int32_t)) {
-        MCE->emitInt32((intptr_t)Jit.getOrEmitGlobalVariable(GV));
+        JCE->emitInt32((intptr_t)Jit.getOrEmitGlobalVariable(GV));
       } else {
-        MCE->emitInt64((intptr_t)Jit.getOrEmitGlobalVariable(GV));
+        JCE->emitInt64((intptr_t)Jit.getOrEmitGlobalVariable(GV));
       }
     } else {
       if (TD->getPointerSize() == sizeof(int32_t))
-        MCE->emitInt32(0);
+        JCE->emitInt32(0);
       else
-        MCE->emitInt64(0);
+        JCE->emitInt64(0);
     }
     // Asm->EOL("TypeInfo");
   }
@@ -492,11 +492,11 @@
   // Emit the filter typeids.
   for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) {
     unsigned TypeID = FilterIds[j];
-    MCE->emitULEB128Bytes(TypeID);
+    JCE->emitULEB128Bytes(TypeID);
     //Asm->EOL("Filter TypeInfo index");
   }
   
-  MCE->emitAlignment(4);
+  JCE->emitAlignment(4);
 
   return DwarfExceptionTable;
 }
@@ -507,48 +507,48 @@
   int stackGrowth = stackGrowthDirection == TargetFrameInfo::StackGrowsUp ?
           PointerSize : -PointerSize;
   
-  unsigned char* StartCommonPtr = (unsigned char*)MCE->getCurrentPCValue();
+  unsigned char* StartCommonPtr = (unsigned char*)JCE->getCurrentPCValue();
   // EH Common Frame header
-  MCE->allocateSpace(4, 0);
-  unsigned char* FrameCommonBeginPtr = (unsigned char*)MCE->getCurrentPCValue();
-  MCE->emitInt32((int)0);
-  MCE->emitByte(dwarf::DW_CIE_VERSION);
-  MCE->emitString(Personality ? "zPLR" : "zR");
-  MCE->emitULEB128Bytes(1);
-  MCE->emitSLEB128Bytes(stackGrowth);
-  MCE->emitByte(RI->getDwarfRegNum(RI->getRARegister(), true));
+  JCE->allocateSpace(4, 0);
+  unsigned char* FrameCommonBeginPtr = (unsigned char*)JCE->getCurrentPCValue();
+  JCE->emitInt32((int)0);
+  JCE->emitByte(dwarf::DW_CIE_VERSION);
+  JCE->emitString(Personality ? "zPLR" : "zR");
+  JCE->emitULEB128Bytes(1);
+  JCE->emitSLEB128Bytes(stackGrowth);
+  JCE->emitByte(RI->getDwarfRegNum(RI->getRARegister(), true));
   
   if (Personality) {
     // Augmentation Size: 3 small ULEBs of one byte each, and the personality
     // function which size is PointerSize.
-    MCE->emitULEB128Bytes(3 + PointerSize); 
+    JCE->emitULEB128Bytes(3 + PointerSize); 
     
     // We set the encoding of the personality as direct encoding because we use
     // the function pointer. The encoding is not relative because the current
     // PC value may be bigger than the personality function pointer.
     if (PointerSize == 4) {
-      MCE->emitByte(dwarf::DW_EH_PE_sdata4); 
-      MCE->emitInt32(((intptr_t)Jit.getPointerToGlobal(Personality)));
+      JCE->emitByte(dwarf::DW_EH_PE_sdata4); 
+      JCE->emitInt32(((intptr_t)Jit.getPointerToGlobal(Personality)));
     } else {
-      MCE->emitByte(dwarf::DW_EH_PE_sdata8);
-      MCE->emitInt64(((intptr_t)Jit.getPointerToGlobal(Personality)));
+      JCE->emitByte(dwarf::DW_EH_PE_sdata8);
+      JCE->emitInt64(((intptr_t)Jit.getPointerToGlobal(Personality)));
     }
     
-    MCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
-    MCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
+    JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
+    JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
       
   } else {
-    MCE->emitULEB128Bytes(1);
-    MCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
+    JCE->emitULEB128Bytes(1);
+    JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
   }
 
   std::vector<MachineMove> Moves;
   RI->getInitialFrameState(Moves);
   EmitFrameMoves(0, Moves);
-  MCE->emitAlignment(PointerSize);
+  JCE->emitAlignment(PointerSize);
   
-  MCE->emitInt32At((uintptr_t*)StartCommonPtr, 
-              (uintptr_t)((unsigned char*)MCE->getCurrentPCValue() - 
+  JCE->emitInt32At((uintptr_t*)StartCommonPtr, 
+              (uintptr_t)((unsigned char*)JCE->getCurrentPCValue() - 
                           FrameCommonBeginPtr));
 
   return StartCommonPtr;
@@ -564,46 +564,46 @@
   unsigned PointerSize = TD->getPointerSize();
   
   // EH frame header.
-  unsigned char* StartEHPtr = (unsigned char*)MCE->getCurrentPCValue();
-  MCE->allocateSpace(4, 0);
-  unsigned char* FrameBeginPtr = (unsigned char*)MCE->getCurrentPCValue();
+  unsigned char* StartEHPtr = (unsigned char*)JCE->getCurrentPCValue();
+  JCE->allocateSpace(4, 0);
+  unsigned char* FrameBeginPtr = (unsigned char*)JCE->getCurrentPCValue();
   // FDE CIE Offset
-  MCE->emitInt32(FrameBeginPtr - StartCommonPtr);
-  MCE->emitInt32(StartFunction - (unsigned char*)MCE->getCurrentPCValue());
-  MCE->emitInt32(EndFunction - StartFunction);
+  JCE->emitInt32(FrameBeginPtr - StartCommonPtr);
+  JCE->emitInt32(StartFunction - (unsigned char*)JCE->getCurrentPCValue());
+  JCE->emitInt32(EndFunction - StartFunction);
 
   // If there is a personality and landing pads then point to the language
   // specific data area in the exception table.
   if (MMI->getPersonalityIndex()) {
-    MCE->emitULEB128Bytes(4);
+    JCE->emitULEB128Bytes(4);
         
     if (!MMI->getLandingPads().empty()) {
-      MCE->emitInt32(ExceptionTable - (unsigned char*)MCE->getCurrentPCValue());
+      JCE->emitInt32(ExceptionTable - (unsigned char*)JCE->getCurrentPCValue());
     } else {
-      MCE->emitInt32((int)0);
+      JCE->emitInt32((int)0);
     }
   } else {
-    MCE->emitULEB128Bytes(0);
+    JCE->emitULEB128Bytes(0);
   }
       
   // Indicate locations of function specific  callee saved registers in
   // frame.
   EmitFrameMoves((intptr_t)StartFunction, MMI->getFrameMoves());
       
-  MCE->emitAlignment(PointerSize);
+  JCE->emitAlignment(PointerSize);
   
   // Indicate the size of the table
-  MCE->emitInt32At((uintptr_t*)StartEHPtr, 
-              (uintptr_t)((unsigned char*)MCE->getCurrentPCValue() - 
+  JCE->emitInt32At((uintptr_t*)StartEHPtr, 
+              (uintptr_t)((unsigned char*)JCE->getCurrentPCValue() - 
                           StartEHPtr));
   
   // Double zeroes for the unwind runtime
   if (PointerSize == 8) {
-    MCE->emitInt64(0);
-    MCE->emitInt64(0);
+    JCE->emitInt64(0);
+    JCE->emitInt64(0);
   } else {
-    MCE->emitInt32(0);
-    MCE->emitInt32(0);
+    JCE->emitInt32(0);
+    JCE->emitInt32(0);
   }
 
   
@@ -611,7 +611,7 @@
 }
 
 unsigned JITDwarfEmitter::GetDwarfTableSizeInBytes(MachineFunction& F,
-                                         MachineCodeEmitter& mce,
+                                         JITCodeEmitter& jce,
                                          unsigned char* StartFunction,
                                          unsigned char* EndFunction) {
   const TargetMachine& TM = F.getTarget();
@@ -619,7 +619,7 @@
   needsIndirectEncoding = TM.getTargetAsmInfo()->getNeedsIndirectEncoding();
   stackGrowthDirection = TM.getFrameInfo()->getStackGrowthDirection();
   RI = TM.getRegisterInfo();
-  MCE = &mce;
+  JCE = &jce;
   unsigned FinalSize = 0;
   
   FinalSize += GetExceptionTableSizeInBytes(&F);
@@ -733,7 +733,7 @@
     }
     
     intptr_t LabelPtr = 0;
-    if (LabelID) LabelPtr = MCE->getLabelAddress(LabelID);
+    if (LabelID) LabelPtr = JCE->getLabelAddress(LabelID);
 
     const MachineLocation &Dst = Move.getDestination();
     const MachineLocation &Src = Move.getSource();
diff --git a/lib/ExecutionEngine/JIT/JITDwarfEmitter.h b/lib/ExecutionEngine/JIT/JITDwarfEmitter.h
index cf5681e..9120ed4 100644
--- a/lib/ExecutionEngine/JIT/JITDwarfEmitter.h
+++ b/lib/ExecutionEngine/JIT/JITDwarfEmitter.h
@@ -18,7 +18,7 @@
 namespace llvm {
 
 class Function;
-class MachineCodeEmitter;
+class JITCodeEmitter;
 class MachineFunction;
 class MachineModuleInfo;
 class MachineMove;
@@ -28,7 +28,7 @@
 
 class JITDwarfEmitter {
   const TargetData* TD;
-  MachineCodeEmitter* MCE;
+  JITCodeEmitter* JCE;
   const TargetRegisterInfo* RI;
   MachineModuleInfo* MMI;
   JIT& Jit;
@@ -66,13 +66,13 @@
   JITDwarfEmitter(JIT& jit);
   
   unsigned char* EmitDwarfTable(MachineFunction& F, 
-                                MachineCodeEmitter& MCE,
+                                JITCodeEmitter& JCE,
                                 unsigned char* StartFunction,
                                 unsigned char* EndFunction);
   
   
   unsigned GetDwarfTableSizeInBytes(MachineFunction& F, 
-                                    MachineCodeEmitter& MCE,
+                                    JITCodeEmitter& JCE,
                                     unsigned char* StartFunction,
                                     unsigned char* EndFunction);
 
diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp
index fe1d96a..89131a0 100644
--- a/lib/ExecutionEngine/JIT/JITEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp
@@ -18,7 +18,7 @@
 #include "llvm/Constants.h"
 #include "llvm/Module.h"
 #include "llvm/DerivedTypes.h"
-#include "llvm/CodeGen/MachineCodeEmitter.h"
+#include "llvm/CodeGen/JITCodeEmitter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
@@ -546,7 +546,7 @@
 namespace {
   /// JITEmitter - The JIT implementation of the MachineCodeEmitter, which is
   /// used to output functions to memory for execution.
-  class JITEmitter : public MachineCodeEmitter {
+  class JITEmitter : public JITCodeEmitter {
     JITMemoryManager *MemMgr;
 
     // When outputting a function stub in the context of some other function, we
@@ -1289,7 +1289,7 @@
 
 void* JITEmitter::allocateSpace(uintptr_t Size, unsigned Alignment) {
   if (BufferBegin)
-    return MachineCodeEmitter::allocateSpace(Size, Alignment);
+    return JITCodeEmitter::allocateSpace(Size, Alignment);
 
   // create a new memory block if there is no active one.
   // care must be taken so that BufferBegin is invalidated when a
@@ -1460,7 +1460,7 @@
 //  Public interface to this file
 //===----------------------------------------------------------------------===//
 
-MachineCodeEmitter *JIT::createEmitter(JIT &jit, JITMemoryManager *JMM) {
+JITCodeEmitter *JIT::createEmitter(JIT &jit, JITMemoryManager *JMM) {
   return new JITEmitter(jit, JMM);
 }
 
@@ -1487,13 +1487,13 @@
     return Addr;
   
   // Get a stub if the target supports it.
-  assert(isa<JITEmitter>(MCE) && "Unexpected MCE?");
+  assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
   return JE->getJITResolver().getFunctionStub(F);
 }
 
 void JIT::registerMachineCodeInfo(MachineCodeInfo *mc) {
-  assert(isa<JITEmitter>(MCE) && "Unexpected MCE?");
+  assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
 
   JE->setMachineCodeInfo(mc);
@@ -1501,7 +1501,7 @@
 
 void JIT::updateFunctionStub(Function *F) {
   // Get the empty stub we generated earlier.
-  assert(isa<JITEmitter>(MCE) && "Unexpected MCE?");
+  assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
   void *Stub = JE->getJITResolver().getFunctionStub(F);
 
@@ -1515,7 +1515,7 @@
 /// that were emitted during code generation.
 ///
 void JIT::updateDlsymStubTable() {
-  assert(isa<JITEmitter>(MCE) && "Unexpected MCE?");
+  assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
   JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
   
   SmallVector<GlobalValue*, 8> GVs;
@@ -1553,11 +1553,11 @@
   JE->startGVStub(0, offset, 4);
   
   // Emit the number of records
-  MCE->emitInt32(nStubs);
+  JE->emitInt32(nStubs);
   
   // Emit the string offsets
   for (unsigned i = 0; i != nStubs; ++i)
-    MCE->emitInt32(Offsets[i]);
+    JE->emitInt32(Offsets[i]);
   
   // Emit the pointers.  Verify that they are at least 2-byte aligned, and set
   // the low bit to 0 == GV, 1 == Function, so that the client code doing the
@@ -1571,26 +1571,26 @@
       Ptr |= (intptr_t)1;
            
     if (sizeof(Ptr) == 8)
-      MCE->emitInt64(Ptr);
+      JE->emitInt64(Ptr);
     else
-      MCE->emitInt32(Ptr);
+      JE->emitInt32(Ptr);
   }
   for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end(); 
        i != e; ++i) {
     intptr_t Ptr = (intptr_t)i->second | 1;
 
     if (sizeof(Ptr) == 8)
-      MCE->emitInt64(Ptr);
+      JE->emitInt64(Ptr);
     else
-      MCE->emitInt32(Ptr);
+      JE->emitInt32(Ptr);
   }
   
   // Emit the strings.
   for (unsigned i = 0; i != GVs.size(); ++i)
-    MCE->emitString(GVs[i]->getName());
+    JE->emitString(GVs[i]->getName());
   for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end(); 
        i != e; ++i)
-    MCE->emitString(i->first());
+    JE->emitString(i->first());
   
   // Tell the JIT memory manager where it is.  The JIT Memory Manager will
   // deallocate space for the old one, if one existed.
@@ -1609,7 +1609,7 @@
     RemoveFunctionFromSymbolTable(OldPtr);
 
   // Free the actual memory for the function body and related stuff.
-  assert(isa<JITEmitter>(MCE) && "Unexpected MCE?");
-  cast<JITEmitter>(MCE)->deallocateMemForFunction(F);
+  assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
+  cast<JITEmitter>(JCE)->deallocateMemForFunction(F);
 }