Implement lazy resolution of function calls

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

tools/jello/Emitter.cpp

@@ -68,7 +68,9 @@ void Emitter::emitByte(unsigned char B) {
 // resolved on demand.  Keep track of these markers.
 //
 void Emitter::emitPCRelativeDisp(Value *V) {
-  unsigned ZeroAddr = -(unsigned)CurByte;  // Calculate displacement to null
+  TheVM.addFunctionRef(CurByte, cast<Function>(V));
+
+  unsigned ZeroAddr = -(unsigned)CurByte-4; // Calculate displacement to null
   *(unsigned*)CurByte = ZeroAddr;   // 4 byte offset
   CurByte += 4;
 }

tools/jello/VM.cpp

@@ -43,6 +43,21 @@ int VM::run(Function *F) {
   return PF();
 }
 
+void *VM::resolveFunctionReference(void *RefAddr) {
+  Function *F = FunctionRefs[RefAddr];
+  assert(F && "Reference address not known!");
+
+  void *Addr = getPointerToFunction(F);
+  assert(Addr && "Pointer to function unknown!");
+
+  FunctionRefs.erase(RefAddr);
+  return Addr;
+}
+
+const std::string &VM::getFunctionReferencedName(void *RefAddr) {
+  return FunctionRefs[RefAddr]->getName();
+}
+
 
 /// getPointerToFunction - This method is used to get the address of the
 /// specified function, compiling it if neccesary.

tools/jello/VM.h

@@ -10,6 +10,7 @@
 #include "llvm/PassManager.h"
 #include <string>
 #include <map>
+#include <vector>
 
 class TargetMachine;
 class Function;
@@ -23,12 +24,21 @@ class VM {
   PassManager PM;          // Passes to compile a function
   MachineCodeEmitter *MCE; // MCE object
 
+  // GlobalAddress - A mapping between LLVM values and their native code
+  // generated versions...
   std::map<const GlobalValue*, void *> GlobalAddress;
+
+  // FunctionRefs - A mapping between addresses that refer to unresolved
+  // functions and the LLVM function object itself.  This is used by the fault
+  // handler to lazily patch up references...
+  //
+  std::map<void*, Function*> FunctionRefs;
 public:
   VM(const std::string &name, Module &m, TargetMachine &tm)
     : ExeName(name), M(m), TM(tm) {
     MCE = createEmitter(*this);  // Initialize MCE
     setupPassManager();
+    registerCallback();
   }
 
   ~VM();
@@ -41,10 +51,19 @@ public:
     CurVal = Addr;
   }
 
+  void addFunctionRef(void *Ref, Function *F) {
+    FunctionRefs[Ref] = F;
+  }
+
+  const std::string &getFunctionReferencedName(void *RefAddr);
+
+  void *resolveFunctionReference(void *RefAddr);
+
 private:
   static MachineCodeEmitter *createEmitter(VM &V);
   void setupPassManager();
   void *getPointerToFunction(Function *F);
+  void registerCallback();
 };
 
 #endif