[Support/ExecutionEngine] Use const void* for storing pointers-to-global.

[dlj]

Summary

For global variables (and functions), const void* is a reasonable default in
many cases. In cases where writing to a value is necessary (and known to be
safe, such as global initialization in ExecutionEngine), const_cast<> gets back
the mutable value.

A reproducible case where this matters is building against musl-libc. Under
musl, the type of stdin, stdout, and stderr is 'FILE *const'.

From lib/Support/DynamicLibrary.cpp:

// On linux we have a weird situation. The stderr/out/in symbols are both
// macros and global variables because of standards requirements. So, we
// boldly use the EXPLICIT_SYMBOL macro without checking for a #define first.
EXPLICIT_SYMBOL(stderr);
EXPLICIT_SYMBOL(stdout);
EXPLICIT_SYMBOL(stdin);

In this case, EXPLICIT_SYMBOL takes the address of variables of type 'extern
FILE *const', which can be converted to 'const void*', but not to 'void*'. So,
in other words, a global 'T *' is stored by pointer (a 'T **') cast to 'void*',
but a global 'T *const' stored by pointer is a 'T *const *', which can be
converted to 'const void *' (but not 'void *').

The ExecutionEngine changes might be separable, but it seems slightly better to
keep consistent const-correctness. That means pushing const_cast down to where
it is known to be safe, as opposed of casting away const from variables early,
when we know it is not generally safe to do so.

[chandlerc]

Sorry, I really think you want Lang or someone more familiar with EE to review this...

[dlj]

Ping for Lang...

include/llvm-c/ExecutionEngine.h

 
 LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
 
 unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
 
 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
                                          LLVMBool IsSigned);
 
-void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
+const void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
 
 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
 
 void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
 
 /*===-- Operations on execution engines -----------------------------------===*/
 
 LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,

 
 LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
 LLVMTargetMachineRef
 LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE);
 
 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
                           void* Addr);
 
-void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
+const void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE,
+                                   LLVMValueRef Global);
 
 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name);
 
 uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name);
 
 /*===-- Operations on memory managers -------------------------------------===*/
 
 typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(

include/llvm-c/Support.h

 
 /**
  * This function will search through all previously loaded dynamic
  * libraries for the symbol \p symbolName. If it is found, the address of
  * that symbol is returned. If not, null is returned.
  *
  * @see sys::DynamicLibrary::SearchForAddressOfSymbol()
  */
-void *LLVMSearchForAddressOfSymbol(const char *symbolName);
+const void *LLVMSearchForAddressOfSymbol(const char *symbolName);
 
 /**
  * This functions permanently adds the symbol \p symbolName with the
  * value \p symbolValue.  These symbols are searched before any
  * libraries.
  *
  * @see sys::DynamicLibrary::AddSymbol()
  */
 void LLVMAddSymbol(const char *symbolName, void *symbolValue);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif

include/llvm/ExecutionEngine/ExecutionEngine.h

public:
   }
 
   /// \brief Erase an entry from the mapping table.
   ///
   /// \returns The address that \p ToUnmap was happed to.
   uint64_t RemoveMapping(StringRef Name);
 };
 
-using FunctionCreator = std::function<void *(const std::string &)>;
+using FunctionCreator = std::function<const void *(const std::string &)>;
 
 /// \brief Abstract interface for implementation execution of LLVM modules,
 /// designed to support both interpreter and just-in-time (JIT) compiler
 /// implementations.
 class ExecutionEngine {
   /// The state object holding the global address mapping, which must be
   /// accessed synchronously.
   //
public:
   /// specified function by using the dlsym function call.  As such it is only
   /// useful for resolving library symbols, not code generated symbols.
   ///
   /// 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.
   ///
   /// This function is deprecated for the MCJIT execution engine.
-  virtual void *getPointerToNamedFunction(StringRef Name,
+  virtual const void *getPointerToNamedFunction(StringRef Name,
                                                 bool AbortOnFailure = true) = 0;
 
   /// mapSectionAddress - map a section to its target address space value.
   /// Map the address of a JIT section as returned from the memory manager
   /// to the address in the target process as the running code will see it.
   /// This is the address which will be used for relocation resolution.
   virtual void mapSectionAddress(const void *LocalAddress,
                                  uint64_t TargetAddress) {
     llvm_unreachable("Re-mapping of section addresses not supported with this "
public:
 
   /// addGlobalMapping - Tell the execution engine that the specified global is
   /// at the specified location.  This is used internally as functions are JIT'd
   /// and as global variables are laid out in memory.  It can and should also be
   /// used by clients of the EE that want to have an LLVM global overlay
   /// existing data in memory. Values to be mapped should be named, and have
   /// external or weak linkage. Mappings are automatically removed when their
   /// GlobalValue is destroyed.
-  void addGlobalMapping(const GlobalValue *GV, void *Addr);
+  void addGlobalMapping(const GlobalValue *GV, const void *Addr);
   void addGlobalMapping(StringRef Name, uint64_t Addr);
 
   /// clearAllGlobalMappings - Clear all global mappings and start over again,
   /// for use in dynamic compilation scenarios to move globals.
   void clearAllGlobalMappings();
 
   /// clearGlobalMappingsFromModule - Clear all global mappings that came from a
   /// particular module, because it has been removed from the JIT.
   void clearGlobalMappingsFromModule(Module *M);
 
   /// updateGlobalMapping - Replace an existing mapping for GV with a new
   /// address.  This updates both maps as required.  If "Addr" is null, the
   /// entry for the global is removed from the mappings.  This returns the old
   /// value of the pointer, or null if it was not in the map.
-  uint64_t updateGlobalMapping(const GlobalValue *GV, void *Addr);
+  uint64_t updateGlobalMapping(const GlobalValue *GV, const void *Addr);
   uint64_t updateGlobalMapping(StringRef Name, uint64_t Addr);
 
   /// getAddressToGlobalIfAvailable - This returns the address of the specified
   /// global symbol.
   uint64_t getAddressToGlobalIfAvailable(StringRef S);
 
   /// getPointerToGlobalIfAvailable - This returns the address of the specified
   /// global value if it is has already been codegen'd, otherwise it returns
   /// null.
-  void *getPointerToGlobalIfAvailable(StringRef S);
-  void *getPointerToGlobalIfAvailable(const GlobalValue *GV);
+  const void *getPointerToGlobalIfAvailable(StringRef S);
+  const void *getPointerToGlobalIfAvailable(const GlobalValue *GV);
 
   /// getPointerToGlobal - This returns the address of the specified global
   /// value. This may involve code generation if it's a function.
   ///
   /// This function is deprecated for the MCJIT execution engine.  Use
   /// getGlobalValueAddress instead.
-  void *getPointerToGlobal(const GlobalValue *GV);
+  const void *getPointerToGlobal(const GlobalValue *GV);
 
   /// getPointerToFunction - The different EE's represent function bodies in
   /// different ways.  They should each implement this to say what a function
   /// pointer should look like.  When F is destroyed, the ExecutionEngine will
   /// remove its global mapping and free any machine code.  Be sure no threads
   /// are running inside F when that happens.
   ///
   /// This function is deprecated for the MCJIT execution engine.  Use
   /// getFunctionAddress instead.
-  virtual void *getPointerToFunction(Function *F) = 0;
+  virtual const void *getPointerToFunction(Function *F) = 0;
 
   /// getPointerToFunctionOrStub - If the specified function has been
   /// code-gen'd, return a pointer to the function.  If not, compile it, or use
   /// a stub to implement lazy compilation if available.  See
   /// getPointerToFunction for the requirements on destroying F.
   ///
   /// This function is deprecated for the MCJIT execution engine.  Use
   /// getFunctionAddress instead.
-  virtual void *getPointerToFunctionOrStub(Function *F) {
+  virtual const void *getPointerToFunctionOrStub(Function *F) {
     // Default implementation, just codegen the function.
     return getPointerToFunction(F);
   }
 
   /// getGlobalValueAddress - Return the address of the specified global
   /// value. This may involve code generation.
   ///
   /// This function should not be called with the interpreter engine.
public:
   void InitializeMemory(const Constant *Init, void *Addr);
 
   /// getOrEmitGlobalVariable - Return the address of the specified global
   /// variable, possibly emitting it to memory if needed.  This is used by the
   /// Emitter.
   ///
   /// This function is deprecated for the MCJIT execution engine.  Use
   /// getGlobalValueAddress instead.
-  virtual void *getOrEmitGlobalVariable(const GlobalVariable *GV) {
+  virtual const void *getOrEmitGlobalVariable(const GlobalVariable *GV) {
     return getPointerToGlobal((const GlobalValue *)GV);
   }
 
   /// Registers a listener to be called back on various events within
   /// the JIT.  See JITEventListener.h for more details.  Does not
   /// take ownership of the argument.  The argument may be NULL, in
   /// which case these functions do nothing.
   virtual void RegisterJITEventListener(JITEventListener *) {}

include/llvm/ExecutionEngine/GenericValue.h

 #define LLVM_EXECUTIONENGINE_GENERICVALUE_H
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/Support/DataTypes.h"
 #include <vector>
 
 namespace llvm {
 
-typedef void* PointerTy;
+typedef const void* PointerTy;
 class APInt;
 
 struct GenericValue {
   struct IntPair {
     unsigned int first;
     unsigned int second;
   };
   union {
     double          DoubleVal;
     float           FloatVal;
     PointerTy       PointerVal;
     struct IntPair  UIntPairVal;
     unsigned char   Untyped[8];
   };
   APInt IntVal;   // also used for long doubles.
   // For aggregate data types.
   std::vector<GenericValue> AggregateVal;
 
   // to make code faster, set GenericValue to zero could be omitted, but it is
   // potentially can cause problems, since GenericValue to store garbage
   // instead of zero.
   GenericValue() : IntVal(1,0) {UIntPairVal.first = 0; UIntPairVal.second = 0;}
-  explicit GenericValue(void *V) : PointerVal(V), IntVal(1,0) { }
+  explicit GenericValue(const void *V) : PointerVal(V), IntVal(1,0) { }
 };
 
-inline GenericValue PTOGV(void *P) { return GenericValue(P); }
-inline void* GVTOP(const GenericValue &GV) { return GV.PointerVal; }
+inline GenericValue PTOGV(const void *P) { return GenericValue(P); }
+inline const void* GVTOP(const GenericValue &GV) { return GV.PointerVal; }
 
 } // End llvm namespace.
 #endif

include/llvm/Support/DynamicLibrary.h

public:
 
     /// This function will search through all previously loaded dynamic
     /// libraries for the symbol \p symbolName. If it is found, the address of
     /// that symbol is returned. If not, null is returned. Note that this will
     /// search permanently loaded libraries (getPermanentLibrary()) as well
     /// as explicitly registered symbols (AddSymbol()).
     /// @throws std::string on error.
     /// @brief Search through libraries for address of a symbol
-    static void *SearchForAddressOfSymbol(const char *symbolName);
+    static const void *SearchForAddressOfSymbol(const char *symbolName);
 
     /// @brief Convenience function for C++ophiles.
-    static void *SearchForAddressOfSymbol(const std::string &symbolName) {
+    static const void *SearchForAddressOfSymbol(const std::string &symbolName) {
       return SearchForAddressOfSymbol(symbolName.c_str());
     }
 
     /// This functions permanently adds the symbol \p symbolName with the
     /// value \p symbolValue.  These symbols are searched before any
     /// libraries.
     /// @brief Add searchable symbol/value pair.
     static void AddSymbol(StringRef symbolName, void *symbolValue);
   };
 
 } // End sys namespace
 } // End llvm namespace
 
 #endif

lib/ExecutionEngine/ExecutionEngine.cpp

const DataLayout &DL =
     GV->getParent()->getDataLayout().isDefault()
       ? getDataLayout()
       : GV->getParent()->getDataLayout();
 
   Mangler::getNameWithPrefix(FullName, GV->getName(), DL);
   return FullName.str();
 }
 
-void ExecutionEngine::addGlobalMapping(const GlobalValue *GV, void *Addr) {
+void ExecutionEngine::addGlobalMapping(const GlobalValue *GV,
+                                       const void *Addr) {
   MutexGuard locked(lock);
   addGlobalMapping(getMangledName(GV), (uint64_t) Addr);
 }
 
 void ExecutionEngine::addGlobalMapping(StringRef Name, uint64_t Addr) {
   MutexGuard locked(lock);
 
   assert(!Name.empty() && "Empty GlobalMapping symbol name!");

 void ExecutionEngine::clearGlobalMappingsFromModule(Module *M) {
   MutexGuard locked(lock);
 
   for (GlobalObject &GO : M->global_objects())
     EEState.RemoveMapping(getMangledName(&GO));
 }
 
 uint64_t ExecutionEngine::updateGlobalMapping(const GlobalValue *GV,
-                                              void *Addr) {
+                                              const void *Addr) {
   MutexGuard locked(lock);
   return updateGlobalMapping(getMangledName(GV), (uint64_t) Addr);
 }
 
 uint64_t ExecutionEngine::updateGlobalMapping(StringRef Name, uint64_t Addr) {
   MutexGuard locked(lock);
 
   ExecutionEngineState::GlobalAddressMapTy &Map =
uint64_t ExecutionEngine::getAddressToGlobalIfAvailable(StringRef S) {
   ExecutionEngineState::GlobalAddressMapTy::iterator I =
     EEState.getGlobalAddressMap().find(S);
   if (I != EEState.getGlobalAddressMap().end())
     Address = I->second;
   return Address;
 }
 
 
-void *ExecutionEngine::getPointerToGlobalIfAvailable(StringRef S) {
+const void *ExecutionEngine::getPointerToGlobalIfAvailable(StringRef S) {
   MutexGuard locked(lock);
   if (void* Address = (void *) getAddressToGlobalIfAvailable(S))
     return Address;
   return nullptr;
 }
 
-void *ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) {
+const void *
+ExecutionEngine::getPointerToGlobalIfAvailable(const GlobalValue *GV) {
   MutexGuard locked(lock);
   return getPointerToGlobalIfAvailable(getMangledName(GV));
 }
 
 const GlobalValue *ExecutionEngine::getGlobalValueAtAddress(void *Addr) {
   MutexGuard locked(lock);
 
   // If we haven't computed the reverse mapping yet, do so first.

 void ExecutionEngine::runStaticConstructorsDestructors(bool isDtors) {
   // Execute global ctors/dtors for each module in the program.
   for (std::unique_ptr<Module> &M : Modules)
     runStaticConstructorsDestructors(*M, isDtors);
 }
 
 #ifndef NDEBUG
 /// isTargetNullPtr - Return whether the target pointer stored at Loc is null.
-static bool isTargetNullPtr(ExecutionEngine *EE, void *Loc) {
+static bool isTargetNullPtr(ExecutionEngine *EE, const void *Loc) {
   unsigned PtrSize = EE->getDataLayout().getPointerSize();
   for (unsigned i = 0; i < PtrSize; ++i)
     if (*(i + (uint8_t*)Loc))
       return false;
   return true;
 }
 #endif
 
ExecutionEngine *EngineBuilder::create(TargetMachine *TM) {
   if ((WhichEngine & EngineKind::JIT) && !ExecutionEngine::MCJITCtor) {
     if (ErrorStr)
       *ErrorStr = "JIT has not been linked in.";
   }
 
   return nullptr;
 }
 
-void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
+const void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
   if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
     return getPointerToFunction(F);
 
   MutexGuard locked(lock);
-  if (void* P = getPointerToGlobalIfAvailable(GV))
+  if (const void* P = getPointerToGlobalIfAvailable(GV))
     return P;
 
   // Global variable might have been added since interpreter started.
   if (GlobalVariable *GVar =
           const_cast<GlobalVariable *>(dyn_cast<GlobalVariable>(GV)))
     EmitGlobalVariable(GVar);
   else
     llvm_unreachable("Global hasn't had an address allocated yet!");
for (const auto &GV : M.globals()) {
         }
       }
 
       if (!GV.isDeclaration()) {
         addGlobalMapping(&GV, getMemoryForGV(&GV));
       } else {
         // External variable reference. Try to use the dynamic loader to
         // get a pointer to it.
-        if (void *SymAddr =
+        if (const void *SymAddr =
             sys::DynamicLibrary::SearchForAddressOfSymbol(GV.getName()))
           addGlobalMapping(&GV, SymAddr);
         else {
           report_fatal_error("Could not resolve external global address: "
                             +GV.getName());
         }
       }
     }
 
     // If there are multiple modules, map the non-canonical globals to their
     // canonical location.
     if (!NonCanonicalGlobals.empty()) {
       for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {
         const GlobalValue *GV = NonCanonicalGlobals[i];
         const GlobalValue *CGV =
           LinkedGlobalsMap[std::make_pair(GV->getName(), GV->getType())];
-        void *Ptr = getPointerToGlobalIfAvailable(CGV);
+        const void *Ptr = getPointerToGlobalIfAvailable(CGV);
         assert(Ptr && "Canonical global wasn't codegen'd!");
         addGlobalMapping(GV, Ptr);
       }
     }
 
     // Now that all of the globals are set up in memory, loop through them all
     // and initialize their contents.
     for (const auto &GV : M.globals()) {
for (unsigned m = 0, e = Modules.size(); m != e; ++m) {
     }
   }
 }
 
 // EmitGlobalVariable - This method emits the specified global variable to the
 // address specified in GlobalAddresses, or allocates new memory if it's not
 // already in the map.
 void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) {
-  void *GA = getPointerToGlobalIfAvailable(GV);
+  const void *GA = getPointerToGlobalIfAvailable(GV);
 
   if (!GA) {
     // If it's not already specified, allocate memory for the global.
     GA = getMemoryForGV(GV);
 
     // If we failed to allocate memory for this global, return.
     if (!GA) return;
 
     addGlobalMapping(GV, GA);
   }
 
   // Don't initialize if it's thread local, let the client do it.
   if (!GV->isThreadLocal())
-    InitializeMemory(GV->getInitializer(), GA);
+    InitializeMemory(GV->getInitializer(), const_cast<void*>(GA));
 
   Type *ElTy = GV->getValueType();
   size_t GVSize = (size_t)getDataLayout().getTypeAllocSize(ElTy);
   NumInitBytes += (unsigned)GVSize;
   ++NumGlobals;
 }

lib/ExecutionEngine/ExecutionEngineBindings.cpp

unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
                                          LLVMBool IsSigned) {
   GenericValue *GenVal = unwrap(GenValRef);
   if (IsSigned)
     return GenVal->IntVal.getSExtValue();
   else
     return GenVal->IntVal.getZExtValue();
 }
 
-void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
+const void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal) {
   return unwrap(GenVal)->PointerVal;
 }
 
 double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal) {
   switch (unwrap(TyRef)->getTypeID()) {
   case Type::FloatTyID:
     return unwrap(GenVal)->FloatVal;
   case Type::DoubleTyID:
LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE) {
   return wrap(unwrap(EE)->getTargetMachine());
 }
 
 void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
                           void* Addr) {
   unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
 }
 
-void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global) {
+const void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE,
+                                   LLVMValueRef Global) {
   unwrap(EE)->finalizeObject();
   
   return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
 }
 
 uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name) {
   return unwrap(EE)->getGlobalValueAddress(Name);
 }
LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
   functions.FinalizeMemory = FinalizeMemory;
   functions.Destroy = Destroy;
   return wrap(new SimpleBindingMemoryManager(functions, Opaque));
 }
 
 void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM) {
   delete unwrap(MM);
 }
-

lib/ExecutionEngine/Interpreter/Execution.cpp

for (SwitchInst::CaseIt i = I.case_begin(), e = I.case_end(); i != e; ++i) {
     }
   }
   if (!Dest) Dest = I.getDefaultDest();   // No cases matched: use default
   SwitchToNewBasicBlock(Dest, SF);
 }
 
 void Interpreter::visitIndirectBrInst(IndirectBrInst &I) {
   ExecutionContext &SF = ECStack.back();
-  void *Dest = GVTOP(getOperandValue(I.getAddress(), SF));
+  const void *Dest = GVTOP(getOperandValue(I.getAddress(), SF));
   SwitchToNewBasicBlock((BasicBlock*)Dest, SF);
 }
 
 
 // SwitchToNewBasicBlock - This method is used to jump to a new basic block.
 // This function handles the actual updating of block and instruction iterators
 // as well as execution of all of the PHI nodes in the destination block.
 //

lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp

static GenericValue lle_X_memset(FunctionType *FT,
   // so here we return GenericValue with IntVal set to zero
   GenericValue GV;
   GV.IntVal = 0;
   return GV;
 }
 
 static GenericValue lle_X_memcpy(FunctionType *FT,
                                  ArrayRef<GenericValue> Args) {
-  memcpy(GVTOP(Args[0]), GVTOP(Args[1]),
+  memcpy(const_cast<void*>(GVTOP(Args[0])), GVTOP(Args[1]),
          (size_t)(Args[2].IntVal.getLimitedValue()));
 
   // llvm.memcpy* returns void, lle_X_* returns GenericValue,
   // so here we return GenericValue with IntVal set to zero
   GenericValue GV;
   GV.IntVal = 0;
   return GV;
 }

lib/ExecutionEngine/MCJIT/MCJIT.h

public:
   void finalizeLoadedModules();
 
   /// 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.
   void runStaticConstructorsDestructors(bool isDtors) override;
 
-  void *getPointerToFunction(Function *F) override;
+  const void *getPointerToFunction(Function *F) override;
 
   GenericValue runFunction(Function *F,
                            ArrayRef<GenericValue> ArgValues) override;
 
   /// getPointerToNamedFunction - This method returns the address of the
   /// specified function by using the dlsym function call.  As such it is only
   /// useful for resolving library symbols, not code generated symbols.
   ///
   /// 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(StringRef Name,
+  const void *getPointerToNamedFunction(StringRef Name,
                                         bool AbortOnFailure = true) override;
 
   /// mapSectionAddress - map a section to its target address space value.
   /// Map the address of a JIT section as returned from the memory manager
   /// to the address in the target process as the running code will see it.
   /// This is the address which will be used for relocation resolution.
   void mapSectionAddress(const void *LocalAddress,
                          uint64_t TargetAddress) override {
     Dyld.mapSectionAddress(LocalAddress, TargetAddress);

lib/ExecutionEngine/MCJIT/MCJIT.cpp

void MCJIT::finalizeModule(Module *M) {
   // If the module hasn't been compiled, just do that.
   if (!OwnedModules.hasModuleBeenLoaded(M))
     generateCodeForModule(M);
 
   finalizeLoadedModules();
 }
 
 JITSymbol MCJIT::findExistingSymbol(const std::string &Name) {
-  if (void *Addr = getPointerToGlobalIfAvailable(Name))
+  if (const void *Addr = getPointerToGlobalIfAvailable(Name))
     return JITSymbol(static_cast<uint64_t>(
                          reinterpret_cast<uintptr_t>(Addr)),
                      JITSymbolFlags::Exported);
 
   return Dyld.getSymbol(Name);
 }
 
 Module *MCJIT::findModuleForSymbol(const std::string &Name,
uint64_t MCJIT::getFunctionAddress(const std::string &Name) {
   MutexGuard locked(lock);
   uint64_t Result = getSymbolAddress(Name, true);
   if (Result != 0)
     finalizeLoadedModules();
   return Result;
 }
 
 // Deprecated.  Use getFunctionAddress instead.
-void *MCJIT::getPointerToFunction(Function *F) {
+const void *MCJIT::getPointerToFunction(Function *F) {
   MutexGuard locked(lock);
 
   Mangler Mang;
   SmallString<128> Name;
   TM->getNameWithPrefix(Name, F, Mang);
 
   if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) {
     bool AbortOnFailure = !F->hasExternalWeakLinkage();
-    void *Addr = getPointerToNamedFunction(Name, AbortOnFailure);
+    const void *Addr = getPointerToNamedFunction(Name, AbortOnFailure);
     updateGlobalMapping(F, Addr);
     return Addr;
   }
 
   Module *M = F->getParent();
   bool HasBeenAddedButNotLoaded = OwnedModules.hasModuleBeenAddedButNotLoaded(M);
 
   // Make sure the relevant module has been compiled and loaded.
if (!GV)
     GV = FindGlobalVariableNamedInModulePtrSet(Name, AllowInternal, OwnedModules.begin_finalized(),
                                         OwnedModules.end_finalized());
   return GV;
 }
 
 GenericValue MCJIT::runFunction(Function *F, ArrayRef<GenericValue> ArgValues) {
   assert(F && "Function *F was null at entry to run()");
 
-  void *FPtr = getPointerToFunction(F);
+  const void *FPtr = getPointerToFunction(F);
   finalizeModule(F->getParent());
   assert(FPtr && "Pointer to fn's code was null after getPointerToFunction");
   FunctionType *FTy = F->getFunctionType();
   Type *RetTy = FTy->getReturnType();
 
   assert((FTy->getNumParams() == ArgValues.size() ||
           (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
          "Wrong number of arguments passed into function!");
GenericValue MCJIT::runFunction(Function *F, ArrayRef<GenericValue> ArgValues) {
   }
 
   report_fatal_error("MCJIT::runFunction does not support full-featured "
                      "argument passing. Please use "
                      "ExecutionEngine::getFunctionAddress and cast the result "
                      "to the desired function pointer type.");
 }
 
-void *MCJIT::getPointerToNamedFunction(StringRef Name, bool AbortOnFailure) {
+const void *MCJIT::getPointerToNamedFunction(StringRef Name,
+                                             bool AbortOnFailure) {
   if (!isSymbolSearchingDisabled()) {
     void *ptr =
       reinterpret_cast<void*>(
         static_cast<uintptr_t>(Resolver.findSymbol(Name).getAddress()));
     if (ptr)
       return ptr;
   }
 
   /// If a LazyFunctionCreator is installed, use it to get/create the function.
   if (LazyFunctionCreator)
-    if (void *RP = LazyFunctionCreator(Name))
+    if (const void *RP = LazyFunctionCreator(Name))
       return RP;
 
   if (AbortOnFailure) {
     report_fatal_error("Program used external function '"+Name+
                        "' which could not be resolved!");
   }
   return nullptr;
 }

lib/Support/DynamicLibrary.cpp

 }
 
 #endif
 
 namespace llvm {
 void *SearchForAddressOfSpecialSymbol(const char* symbolName);
 }
 
-void* DynamicLibrary::SearchForAddressOfSymbol(const char *symbolName) {
+const void* DynamicLibrary::SearchForAddressOfSymbol(const char *symbolName) {
   SmartScopedLock<true> Lock(*SymbolsMutex);
 
   // First check symbols added via AddSymbol().
   if (ExplicitSymbols.isConstructed()) {
     StringMap<void *>::iterator i = ExplicitSymbols->find(symbolName);
 
     if (i != ExplicitSymbols->end())
       return i->second;

 //===----------------------------------------------------------------------===//
 // C API.
 //===----------------------------------------------------------------------===//
 
 LLVMBool LLVMLoadLibraryPermanently(const char* Filename) {
   return llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename);
 }
 
-void *LLVMSearchForAddressOfSymbol(const char *symbolName) {
+const void *LLVMSearchForAddressOfSymbol(const char *symbolName) {
   return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName);
 }
 
 void LLVMAddSymbol(const char *symbolName, void *symbolValue) {
   return llvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue);
 }
-

unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp

protected:
 
   void compileAndRun(int ExpectedRC = OriginalRC) {
     // This function shouldn't be called until after SetUp.
     ASSERT_TRUE(bool(TheJIT));
     ASSERT_TRUE(nullptr != Main);
 
     // We may be using a null cache, so ensure compilation is valid.
     TheJIT->finalizeObject();
-    void *vPtr = TheJIT->getPointerToFunction(Main);
+    const void *vPtr = TheJIT->getPointerToFunction(Main);
 
     EXPECT_TRUE(nullptr != vPtr)
       << "Unable to get pointer to main() from JIT";
 
     int (*FuncPtr)() = (int(*)())(intptr_t)vPtr;
     int returnCode = FuncPtr();
     EXPECT_EQ(returnCode, ExpectedRC);
   }

unittests/ExecutionEngine/MCJIT/MCJITTest.cpp

 */
 
 TEST_F(MCJITTest, global_variable) {
   SKIP_UNSUPPORTED_PLATFORM;
 
   int initialValue = 5;
   GlobalValue *Global = insertGlobalInt32(M.get(), "test_global", initialValue);
   createJIT(std::move(M));
-  void *globalPtr =  TheJIT->getPointerToGlobal(Global);
+  const void *globalPtr =  TheJIT->getPointerToGlobal(Global);
   EXPECT_TRUE(nullptr != globalPtr)
     << "Unable to get pointer to global value from JIT";
 
   EXPECT_EQ(initialValue, *(int32_t*)globalPtr)
     << "Unexpected initial value of global";
 }
 
 TEST_F(MCJITTest, add_function) {

 
 #endif /*!defined(__arm__)*/
 
 TEST_F(MCJITTest, multiple_decl_lookups) {
   SKIP_UNSUPPORTED_PLATFORM;
 
   Function *Foo = insertExternalReferenceToFunction<void(void)>(M.get(), "_exit");
   createJIT(std::move(M));
-  void *A = TheJIT->getPointerToFunction(Foo);
-  void *B = TheJIT->getPointerToFunction(Foo);
+  const void *A = TheJIT->getPointerToFunction(Foo);
+  const void *B = TheJIT->getPointerToFunction(Foo);
 
   EXPECT_TRUE(A != nullptr) << "Failed lookup - test not correctly configured.";
   EXPECT_EQ(A, B) << "Repeat calls to getPointerToFunction fail.";
 }
 
-typedef void * (*FunctionHandlerPtr)(const std::string &str);
+typedef const void * (*FunctionHandlerPtr)(const std::string &str);
 
 TEST_F(MCJITTest, lazy_function_creator_pointer) {
   SKIP_UNSUPPORTED_PLATFORM;
   
   Function *Foo = insertExternalReferenceToFunction<int32_t(void)>(M.get(),
                                                                    "\1Foo");
   startFunction<int32_t(void)>(M.get(), "Parent");
   CallInst *Call = Builder.CreateCall(Foo, {});
   Builder.CreateRet(Call);
   
   createJIT(std::move(M));
   
   // Set up the lazy function creator that records the name of the last
   // unresolved external function found in the module. Using a function pointer
   // prevents us from capturing local variables, which is why this is static.
   static std::string UnresolvedExternal;
   FunctionHandlerPtr UnresolvedHandler = [] (const std::string &str) {
     // Try to resolve the function in the current process before marking it as
     // unresolved. This solves an issue on ARM where '__aeabi_*' function names
     // are passed to this handler.
-    void *symbol =
+    const void *symbol =
         llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(str.c_str());
     if (symbol) {
       return symbol;
     }
     
     UnresolvedExternal = str;
-    return (void *)(uintptr_t)-1;
+    return (const void *)(uintptr_t)-1;
   };
   TheJIT->InstallLazyFunctionCreator(UnresolvedHandler);
   
   // JIT the module.
   TheJIT->finalizeObject();
   
   // Verify that our handler was called.
   EXPECT_EQ(UnresolvedExternal, "Foo");
TEST_F(MCJITTest, lazy_function_creator_lambda) {
   
   // Set up the lazy function creator that records the name of unresolved
   // external functions in the module.
   std::vector<std::string> UnresolvedExternals;
   auto UnresolvedHandler = [&UnresolvedExternals] (const std::string &str) {
     // Try to resolve the function in the current process before marking it as
     // unresolved. This solves an issue on ARM where '__aeabi_*' function names
     // are passed to this handler.
-    void *symbol =
+    const void *symbol =
         llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(str.c_str());
     if (symbol) {
       return symbol;
     }
     UnresolvedExternals.push_back(str);
-    return (void *)(uintptr_t)-1;
+    return (const void *)(uintptr_t)-1;
   };
   TheJIT->InstallLazyFunctionCreator(UnresolvedHandler);
   
   // JIT the module.
   TheJIT->finalizeObject();
   
   // Verify that our handler was called for each unresolved function.
   auto I = UnresolvedExternals.begin(), E = UnresolvedExternals.end();
   EXPECT_EQ(UnresolvedExternals.size(), 2u);
   EXPECT_FALSE(std::find(I, E, "Foo1") == E);
   EXPECT_FALSE(std::find(I, E, "Foo2") == E);
 }
 
 } // end anonymous namespace