Suck block address tracking out of targets into the JIT Emitter. This

[oota-llvm.git] / lib / Target / X86 / X86CodeEmitter.cpp

diff --git a/lib/Target/X86/X86CodeEmitter.cpp b/lib/Target/X86/X86CodeEmitter.cpp
index 51be7b82dec8522e7c7e563f0111fa6ef461a995..4dd95598a6f5e6c07285de1fa09459492327fef7 100644 (file)
--- a/lib/Target/X86/X86CodeEmitter.cpp
+++ b/lib/Target/X86/X86CodeEmitter.cpp
@@ -35,8 +35,7 @@ namespace {
   class Emitter : public MachineFunctionPass {
     const X86InstrInfo  *II;
     MachineCodeEmitter  &MCE;
-    std::map<const MachineBasicBlock*, unsigned> BasicBlockAddrs;
-    std::vector<std::pair<const MachineBasicBlock *, unsigned> > BBRefs;
+    std::vector<std::pair<MachineBasicBlock *, unsigned> > BBRefs;
   public:
     explicit Emitter(MachineCodeEmitter &mce) : II(0), MCE(mce) {}
     Emitter(MachineCodeEmitter &mce, const X86InstrInfo& ii)
@@ -51,9 +50,8 @@ namespace {
     void emitInstruction(const MachineInstr &MI);
 
   private:
-    void emitBasicBlock(const MachineBasicBlock &MBB);
-
-    void emitPCRelativeBlockAddress(const MachineBasicBlock *BB);
+    void emitBasicBlock(MachineBasicBlock &MBB);
+    void emitPCRelativeBlockAddress(MachineBasicBlock *MBB);
     void emitPCRelativeValue(unsigned Address);
     void emitGlobalAddressForCall(GlobalValue *GV, bool isTailCall);
     void emitGlobalAddressForPtr(GlobalValue *GV, int Disp = 0);
@@ -82,27 +80,26 @@ bool Emitter::runOnMachineFunction(MachineFunction &MF) {
          "JIT relocation model must be set to static or default!");
   II = ((X86TargetMachine&)MF.getTarget()).getInstrInfo();
 
-  MCE.startFunction(MF);
-  MCE.emitConstantPool(MF.getConstantPool());
-  for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
-    emitBasicBlock(*I);
-  MCE.finishFunction(MF);
+  do {
+    BBRefs.clear();
+
+    MCE.startFunction(MF);
+    for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
+      emitBasicBlock(*I);
+  } while (MCE.finishFunction(MF));
 
-  // Resolve all forward branches now...
+  // Resolve all forward branches now.
   for (unsigned i = 0, e = BBRefs.size(); i != e; ++i) {
-    unsigned Location = BasicBlockAddrs[BBRefs[i].first];
+    unsigned Location = MCE.getMachineBasicBlockAddress(BBRefs[i].first);
     unsigned Ref = BBRefs[i].second;
-    MCE.emitWordAt(Location-Ref-4, (unsigned*)(intptr_t)Ref);
+    *((unsigned*)(intptr_t)Ref) = Location-Ref-4;
   }
   BBRefs.clear();
-  BasicBlockAddrs.clear();
   return false;
 }
 
-void Emitter::emitBasicBlock(const MachineBasicBlock &MBB) {
-  if (uint64_t Addr = MCE.getCurrentPCValue())
-    BasicBlockAddrs[&MBB] = Addr;
-
+void Emitter::emitBasicBlock(MachineBasicBlock &MBB) {
+  MCE.StartMachineBasicBlock(&MBB);
   for (MachineBasicBlock::const_iterator I = MBB.begin(), E = MBB.end();
        I != E; ++I)
     emitInstruction(*I);
@@ -111,27 +108,18 @@ void Emitter::emitBasicBlock(const MachineBasicBlock &MBB) {
 /// emitPCRelativeValue - Emit a 32-bit PC relative address.
 ///
 void Emitter::emitPCRelativeValue(unsigned Address) {
-  MCE.emitWord(Address-MCE.getCurrentPCValue()-4);
+  MCE.emitWordLE(Address-MCE.getCurrentPCValue()-4);
 }
 
-/// emitPCRelativeBlockAddress - This method emits the PC relative address of
-/// the specified basic block, or if the basic block hasn't been emitted yet
-/// (because this is a forward branch), it keeps track of the information
-/// necessary to resolve this address later (and emits a dummy value).
+/// emitPCRelativeBlockAddress - This method keeps track of the information
+/// necessary to resolve the address of this block later and emits a dummy
+/// value.
 ///
-void Emitter::emitPCRelativeBlockAddress(const MachineBasicBlock *MBB) {
-  // If this is a backwards branch, we already know the address of the target,
-  // so just emit the value.
-  std::map<const MachineBasicBlock*, unsigned>::iterator I =
-    BasicBlockAddrs.find(MBB);
-  if (I != BasicBlockAddrs.end()) {
-    emitPCRelativeValue(I->second);
-  } else {
-    // Otherwise, remember where this reference was and where it is to so we can
-    // deal with it later.
-    BBRefs.push_back(std::make_pair(MBB, MCE.getCurrentPCValue()));
-    MCE.emitWord(0);
-  }
+void Emitter::emitPCRelativeBlockAddress(MachineBasicBlock *MBB) {
+  // Remember where this reference was and where it is to so we can
+  // deal with it later.
+  BBRefs.push_back(std::make_pair(MBB, MCE.getCurrentPCValue()));
+  MCE.emitWordLE(0);
 }
 
 /// emitGlobalAddressForCall - Emit the specified address to the code stream
@@ -141,7 +129,7 @@ void Emitter::emitGlobalAddressForCall(GlobalValue *GV, bool isTailCall) {
   MCE.addRelocation(MachineRelocation(MCE.getCurrentPCOffset(),
                                       X86::reloc_pcrel_word, GV, 0,
                                       !isTailCall /*Doesn'tNeedStub*/));
-  MCE.emitWord(0);
+  MCE.emitWordLE(0);
 }
 
 /// emitGlobalAddress - Emit the specified address to the code stream assuming
@@ -151,7 +139,7 @@ void Emitter::emitGlobalAddressForCall(GlobalValue *GV, bool isTailCall) {
 void Emitter::emitGlobalAddressForPtr(GlobalValue *GV, int Disp /* = 0 */) {
   MCE.addRelocation(MachineRelocation(MCE.getCurrentPCOffset(),
                                       X86::reloc_absolute_word, GV));
-  MCE.emitWord(Disp);   // The relocated value will be added to the displacement
+  MCE.emitWordLE(Disp); // The relocated value will be added to the displacement
 }
 
 /// emitExternalSymbolAddress - Arrange for the address of an external symbol to
@@ -161,7 +149,7 @@ void Emitter::emitExternalSymbolAddress(const char *ES, bool isPCRelative,
                                         bool isTailCall) {
   MCE.addRelocation(MachineRelocation(MCE.getCurrentPCOffset(),
           isPCRelative ? X86::reloc_pcrel_word : X86::reloc_absolute_word, ES));
-  MCE.emitWord(0);
+  MCE.emitWordLE(0);
 }
 
 /// N86 namespace - Native X86 Register numbers... used by X86 backend.
@@ -242,6 +230,8 @@ void Emitter::emitMemModRMByte(const MachineInstr &MI,
   } else if (Op3.isConstantPoolIndex()) {
     DispVal += MCE.getConstantPoolEntryAddress(Op3.getConstantPoolIndex());
     DispVal += Op3.getOffset();
+  } else if (Op3.isJumpTableIndex()) {
+    DispVal += MCE.getJumpTableEntryAddress(Op3.getJumpTableIndex());
   } else {
     DispVal = Op3.getImmedValue();
   }
@@ -445,6 +435,10 @@ void Emitter::emitInstruction(const MachineInstr &MI) {
         assert(sizeOfImm(Desc) == 4 &&
                "Don't know how to emit non-pointer values!");
         emitExternalSymbolAddress(MO1.getSymbolName(), false, false);
+      } else if (MO1.isJumpTableIndex()) {
+        assert(sizeOfImm(Desc) == 4 &&
+               "Don't know how to emit non-pointer values!");
+        emitConstant(MCE.getJumpTableEntryAddress(MO1.getJumpTableIndex()), 4);
       } else {
         emitConstant(MO1.getImmedValue(), sizeOfImm(Desc));
       }
@@ -508,6 +502,9 @@ void Emitter::emitInstruction(const MachineInstr &MI) {
       else if (MI.getOperand(4).isGlobalAddress())
         emitGlobalAddressForPtr(MI.getOperand(4).getGlobal(),
                                 MI.getOperand(4).getOffset());
+      else if (MI.getOperand(4).isJumpTableIndex())
+        emitConstant(MCE.getJumpTableEntryAddress(MI.getOperand(4)
+                                                    .getJumpTableIndex()), 4);
       else
         assert(0 && "Unknown operand!");
     }