[ExecutionEngine] Fix a compiler warning in StoreValueToMemory

[labath]

Summary

gcc was diagnosing a memcpy in this function with "memcpy writing to an
object of type 'struct llvm::GenericValue' with no trivial
copy-assignment". After closer examination, it became clear that the
pointer in the function *never* refers to a GenericValue object, and all
callers cast some other pointer (typically void*) to GenericValue*.
There doesn't seem to be any reason for such a convoluted solution so I
just change the function to accept a void* instead, which has the nice
side-effect of fixing the warning as well.

[labath]

not relevant anymore

include/llvm/ExecutionEngine/ExecutionEngine.h

public:
   }
 
   /// getGlobalValueAtAddress - Return the LLVM global value object that starts
   /// at the specified address.
   ///
   const GlobalValue *getGlobalValueAtAddress(void *Addr);
 
   /// StoreValueToMemory - Stores the data in Val of type Ty at address Ptr.
-  /// Ptr is the address of the memory at which to store Val, cast to
-  /// GenericValue *.  It is not a pointer to a GenericValue containing the
-  /// address at which to store Val.
-  void StoreValueToMemory(const GenericValue &Val, GenericValue *Ptr,
-                          Type *Ty);
+  /// Ptr is the address of the memory at which to store Val.
+  void StoreValueToMemory(const GenericValue &Val, void *Ptr, Type *Ty);
 
   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

lib/ExecutionEngine/ExecutionEngine.cpp

for (unsigned i = 0; i != InputArgv.size(); ++i) {
     auto Dest = make_unique<char[]>(Size);
     LLVM_DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void *)Dest.get()
                       << "\n");
 
     std::copy(InputArgv[i].begin(), InputArgv[i].end(), Dest.get());
     Dest[Size-1] = 0;
 
     // Endian safe: Array[i] = (PointerTy)Dest;
-    EE->StoreValueToMemory(PTOGV(Dest.get()),
-                           (GenericValue*)(&Array[i*PtrSize]), SBytePtr);
+    EE->StoreValueToMemory(PTOGV(Dest.get()), &Array[i * PtrSize], SBytePtr);
     Values.push_back(std::move(Dest));
   }
 
   // Null terminate it
-  EE->StoreValueToMemory(PTOGV(nullptr),
-                         (GenericValue*)(&Array[InputArgv.size()*PtrSize]),
+  EE->StoreValueToMemory(PTOGV(nullptr), &Array[InputArgv.size() * PtrSize],
                          SBytePtr);
   return Array.get();
 }
 
 void ExecutionEngine::runStaticConstructorsDestructors(Module &module,
                                                        bool isDtors) {
   StringRef Name(isDtors ? "llvm.global_dtors" : "llvm.global_ctors");
   GlobalVariable *GV = module.getNamedGlobal(Name);
while (StoreBytes > sizeof(uint64_t)) {
       memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
       Src += sizeof(uint64_t);
     }
 
     memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
   }
 }
 
-void ExecutionEngine::StoreValueToMemory(const GenericValue &Val,
-                                         GenericValue *Ptr, Type *Ty) {
+void ExecutionEngine::StoreValueToMemory(const GenericValue &Val, void *Ptr,
+                                         Type *Ty) {
   const unsigned StoreBytes = getDataLayout().getTypeStoreSize(Ty);
 
   switch (Ty->getTypeID()) {
   default:
     dbgs() << "Cannot store value of type " << *Ty << "!\n";
     break;
   case Type::IntegerTyID:
     StoreIntToMemory(Val.IntVal, (uint8_t*)Ptr, StoreBytes);
     break;
   case Type::FloatTyID:
     *((float*)Ptr) = Val.FloatVal;
     break;
   case Type::DoubleTyID:
     *((double*)Ptr) = Val.DoubleVal;
     break;
   case Type::X86_FP80TyID:
     memcpy(Ptr, Val.IntVal.getRawData(), 10);
     break;
   case Type::PointerTyID:
     // Ensure 64 bit target pointers are fully initialized on 32 bit hosts.
     if (StoreBytes != sizeof(PointerTy))
-      memset(&(Ptr->PointerVal), 0, StoreBytes);
+      memset(Ptr, 0, StoreBytes);
 
     *((PointerTy*)Ptr) = Val.PointerVal;
     break;
   case Type::VectorTyID:
     for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
       if (cast<VectorType>(Ty)->getElementType()->isDoubleTy())
         *(((double*)Ptr)+i) = Val.AggregateVal[i].DoubleVal;
       if (cast<VectorType>(Ty)->getElementType()->isFloatTy())
if (const ConstantDataSequential *CDS =
     // CDS is already laid out in host memory order.
     StringRef Data = CDS->getRawDataValues();
     memcpy(Addr, Data.data(), Data.size());
     return;
   }
 
   if (Init->getType()->isFirstClassType()) {
     GenericValue Val = getConstantValue(Init);
-    StoreValueToMemory(Val, (GenericValue*)Addr, Init->getType());
+    StoreValueToMemory(Val, Addr, Init->getType());
     return;
   }
 
   LLVM_DEBUG(dbgs() << "Bad Type: " << *Init->getType() << "\n");
   llvm_unreachable("Unknown constant type to initialize memory with!");
 }
 
 /// EmitGlobals - Emit all of the global variables to memory, storing their

lib/ExecutionEngine/Interpreter/Execution.cpp

void Interpreter::visitLoadInst(LoadInst &I) {
   if (I.isVolatile() && PrintVolatile)
     dbgs() << "Volatile load " << I;
 }
 
 void Interpreter::visitStoreInst(StoreInst &I) {
   ExecutionContext &SF = ECStack.back();
   GenericValue Val = getOperandValue(I.getOperand(0), SF);
   GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
-  StoreValueToMemory(Val, (GenericValue *)GVTOP(SRC),
-                     I.getOperand(0)->getType());
+  StoreValueToMemory(Val, GVTOP(SRC), I.getOperand(0)->getType());
   if (I.isVolatile() && PrintVolatile)
     dbgs() << "Volatile store: " << I;
 }
 
 //===----------------------------------------------------------------------===//
 //                 Miscellaneous Instruction Implementations
 //===----------------------------------------------------------------------===//