Missing Dyld error handling

[keder]

Summary

We are using code generation in our module and have encountered the following problem. There is missing error handling in MCJIT::finalizeLoadedModules in lib/ExecutionEngine/MCJIT/MCJIT.cpp. It calls resolveRelocations of dynamic linker which tries to find missing symbols, in case if symbol is missing in both loaded libraries and in executable, dynamic linker sets error, but MCJIT does not handles it in any way and puts nullptr. It leads to jump on zero address further in program execution.
The fix is quite tiny. I have just added error handling like in other functions of MCJIT. I have no commit access to repository by the way.

[keder]

added more context

[lhames]

Thanks Keder!

This looks good to me. I’m just running the regression tests now.

llvm/include/llvm-c/ExecutionEngine.h

void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
                           void* Addr);
 
 void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
 
 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
 
 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
 
+/// Returns true on error, false on success. If true is returned then the error
+/// message is copied to OutStr and cleared in the ExecutionEngine instance.
+LLVMBool LLVMExecutionEngineGetErrMsg(LLVMExecutionEngineRef EE,
+                                      char **OutError);
+
 /*===-- Operations on memory managers -------------------------------------===*/
 
 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
   const char *SectionName);
 typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
   void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
   const char *SectionName, LLVMBool IsReadOnly);

llvm/include/llvm/ExecutionEngine/ExecutionEngine.h

protected:
   /// LazyFunctionCreator - If an unknown function is needed, this function
   /// pointer is invoked to create it.  If this returns null, the JIT will
   /// abort.
   FunctionCreator LazyFunctionCreator;
 
   /// getMangledName - Get mangled name.
   std::string getMangledName(const GlobalValue *GV);
 
+  std::string ErrMsg;
+
 public:
   /// lock - This lock protects the ExecutionEngine and MCJIT classes. It must
   /// be held while changing the internal state of any of those classes.
   sys::Mutex lock;
 
   //===--------------------------------------------------------------------===//
   //  ExecutionEngine Startup
   //===--------------------------------------------------------------------===//
public:
 
   /// finalizeObject - ensure the module is fully processed and is usable.
   ///
   /// It is the user-level function for completing the process of making the
   /// object usable for execution.  It should be called after sections within an
   /// object have been relocated using mapSectionAddress.  When this method is
   /// called the MCJIT execution engine will reapply relocations for a loaded
   /// object.  This method has no effect for the interpeter.
+  ///
+  /// Returns true on success, false on failure. Error messages can be retrieved
+  /// by calling getError();
   virtual void finalizeObject() {}
 
+  /// Returns true if an error has been recorded.
+  bool hasError() const { return !ErrMsg.empty(); }
+
+  /// Clear the error message.
+  void clearErrorMessage() { ErrMsg.clear(); }
+
+  /// Returns the most recent error message.
+  const std::string &getErrorMessage() const { return ErrMsg; }
+
   /// runStaticConstructorsDestructors - This method is used to execute all of
   /// the static constructors or destructors for a program.
   ///
   /// \param isDtors - Run the destructors instead of constructors.
   virtual void runStaticConstructorsDestructors(bool isDtors);
 
   /// This method is used to execute all of the static constructors or
   /// destructors for a particular module.

llvm/lib/ExecutionEngine/ExecutionEngineBindings.cpp

 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name) {
   return unwrap(EE)->getGlobalValueAddress(Name);
 }
 
 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name) {
   return unwrap(EE)->getFunctionAddress(Name);
 }
 
+LLVMBool LLVMExecutionEngineGetErrMsg(LLVMExecutionEngineRef EE,
+                                      char **OutError) {
+  assert(OutError && "OutError must be non-null");
+  auto *ExecEngine = unwrap(EE);
+  if (ExecEngine->hasError()) {
+    *OutError = strdup(ExecEngine->getErrorMessage().c_str());
+    ExecEngine->clearErrorMessage();
+    return true;
+  }
+  return false;
+}
+
 /*===-- Operations on memory managers -------------------------------------===*/
 
 namespace {
 
 struct SimpleBindingMMFunctions {
   LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection;
   LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection;
   LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory;

llvm/lib/ExecutionEngine/MCJIT/MCJIT.cpp

 }
 
 void MCJIT::finalizeLoadedModules() {
   std::lock_guard<sys::Mutex> locked(lock);
 
   // Resolve any outstanding relocations.
   Dyld.resolveRelocations();
 
+  // Check for Dyld error.
+  if (Dyld.hasError())
+    ErrMsg = Dyld.getErrorString().str();
+
   OwnedModules.markAllLoadedModulesAsFinalized();
 
   // Register EH frame data for any module we own which has been loaded
   Dyld.registerEHFrames();
 
   // Set page permissions.
   MemMgr->finalizeMemory();
 }