Handle weak_extern in the JIT. This fixes

SingleSource/UnitTests/2007-04-25-weak.c in JIT mode. The test
now passes on systems which are able to produce a correct
reference output to compare with.

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

diff --git a/lib/ExecutionEngine/JIT/Intercept.cpp b/lib/ExecutionEngine/JIT/Intercept.cpp
index af8b58ed4dc7aa8702925c6f58b5ffde6833958f..1590925b044833a5730c9c308ced4fadd6014c5d 100644 (file)
--- a/lib/ExecutionEngine/JIT/Intercept.cpp
+++ b/lib/ExecutionEngine/JIT/Intercept.cpp
@@ -90,7 +90,8 @@ static int jit_atexit(void (*Fn)(void)) {
 /// function by using the dynamic loader interface.  As such it is only useful
 /// for resolving library symbols, not code generated symbols.
 ///
-void *JIT::getPointerToNamedFunction(const std::string &Name) {
+void *JIT::getPointerToNamedFunction(const std::string &Name,
+                                     bool AbortOnFailure) {
   if (!isSymbolSearchingDisabled()) {
     // Check to see if this is one of the functions we want to intercept.  Note,
     // we cast to intptr_t here to silence a -pedantic warning that complains
@@ -122,9 +123,9 @@ void *JIT::getPointerToNamedFunction(const std::string &Name) {
       // First try turning $LDBLStub into $LDBL128. If that fails, strip it off.
       // This mirrors logic in libSystemStubs.a.
       std::string Prefix = std::string(Name.begin(), Name.end()-9);
-      if (void *Ptr = getPointerToNamedFunction(Prefix+"$LDBL128"))
+      if (void *Ptr = getPointerToNamedFunction(Prefix+"$LDBL128"), false)
         return Ptr;
-      if (void *Ptr = getPointerToNamedFunction(Prefix))
+      if (void *Ptr = getPointerToNamedFunction(Prefix), false)
         return Ptr;
     }
 #endif
@@ -135,8 +136,10 @@ void *JIT::getPointerToNamedFunction(const std::string &Name) {
     if (void *RP = LazyFunctionCreator(Name))
       return RP;
 
-  cerr << "ERROR: Program used external function '" << Name
-       << "' which could not be resolved!\n";
-  abort();
+  if (AbortOnFailure) {
+    cerr << "ERROR: Program used external function '" << Name
+         << "' which could not be resolved!\n";
+    abort();
+  }
   return 0;
 }

diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index 5d5ecc4fe7773fd6dfc352109f6b1c968e25e298..6cd1c509785ecda8fd2c13b1be11625712783942 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -509,16 +509,17 @@ void *JIT::getPointerToFunction(Function *F) {
            << "' from bitcode file: " << ErrorMsg << "\n";
       abort();
     }
-  }
 
-  if (void *Addr = getPointerToGlobalIfAvailable(F)) {
-    return Addr;
+    // Now retry to get the address.
+    if (void *Addr = getPointerToGlobalIfAvailable(F))
+      return Addr;
   }
 
   MutexGuard locked(lock);
 
   if (F->isDeclaration()) {
-    void *Addr = getPointerToNamedFunction(F->getName());
+    bool AbortOnFailure = F->getLinkage() != GlobalValue::ExternalWeakLinkage;
+    void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure);
     addGlobalMapping(F, Addr);
     return Addr;
   }

diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h
index 2eee2e980ce88112b369201cc7b68f5ef76df519..b92999960331ac1651e2d92993851618f6385545 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.h
+++ b/lib/ExecutionEngine/JIT/JIT.h
@@ -89,7 +89,12 @@ public:
   /// specified function by using the dlsym function call.  As such it is only
   /// useful for resolving library symbols, not code generated symbols.
   ///
-  void *getPointerToNamedFunction(const std::string &Name);
+  /// If AbortOnFailure is false and no function with the given name is
+  /// found, this function silently returns a null pointer. Otherwise,
+  /// it prints a message to stderr and aborts.
+  ///
+  void *getPointerToNamedFunction(const std::string &Name,
+                                  bool AbortOnFailure = true);
 
   // CompilationCallback - Invoked the first time that a call site is found,
   // which causes lazy compilation of the target function.

diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp
index e041767f8f345f340606a764c36a76ce025528de..3f3f681f6109dd4fe443f44c9ce8b4999dbfc5c9 100644 (file)
--- a/lib/ExecutionEngine/JIT/JITEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp
@@ -177,9 +177,14 @@ void *JITResolver::getFunctionStub(Function *F) {
   // Call the lazy resolver function unless we already KNOW it is an external
   // function, in which case we just skip the lazy resolution step.
   void *Actual = (void*)(intptr_t)LazyResolverFn;
-  if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode())
+  if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode()) {
     Actual = TheJIT->getPointerToFunction(F);
 
+    // If we resolved the symbol to a null address (eg. a weak external)
+    // don't emit a stub. Return a null pointer to the application.
+    if (!Actual) return 0;
+  }
+
   // Otherwise, codegen a new stub.  For now, the stub will call the lazy
   // resolver function.
   Stub = TheJIT->getJITInfo().emitFunctionStub(F, Actual,
@@ -905,7 +910,8 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
       void *ResultPtr = 0;
       if (!MR.letTargetResolve()) {
         if (MR.isExternalSymbol()) {
-          ResultPtr = TheJIT->getPointerToNamedFunction(MR.getExternalSymbol());
+          ResultPtr = TheJIT->getPointerToNamedFunction(MR.getExternalSymbol(),
+                                                        false);
           DOUT << "JIT: Map \'" << MR.getExternalSymbol() << "\' to ["
                << ResultPtr << "]\n";