[ExecutionEngine] Add support for aggregate constants in the interpreter

[eush]

Summary

This adds support for constants of aggregate types, i.e. structs and arrays.

Previously the conversion from a constant aggregate Value to a GenericValue
was missing in ExecutionEngine::getConstantValue, and this patch implements
just that by writing all elements in sequence into the corresponding
GenericValue field.

[eush]

Fixed compilation under -std=c++11.

lib/ExecutionEngine/ExecutionEngine.cpp

 #include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/IR/Use.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
+#include <algorithm>
 #include <cmath>
 #include <cstring>
+#include <iterator>
 using namespace llvm;
 
 #define DEBUG_TYPE "jit"
 
 STATISTIC(NumInitBytes, "Number of bytes of global vars initialized");
 STATISTIC(NumGlobals  , "Number of global vars initialized");
 
 ExecutionEngine *(*ExecutionEngine::MCJITCtor)(
GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
   case Type::X86_FP80TyID:
   case Type::FP128TyID:
   case Type::PPC_FP128TyID:
     Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
     break;
   case Type::IntegerTyID:
     Result.IntVal = cast<ConstantInt>(C)->getValue();
     break;
+  case Type::StructTyID:
+  case Type::ArrayTyID: {
+    if (!isa<ConstantData>(C)) {
+      std::transform(
+          C->op_begin(), C->op_end(), std::back_inserter(Result.AggregateVal),
+          [this](const Use &E) { return getConstantValue(cast<Constant>(E)); });
+      break;
+    }
+
+    auto *CDS = dyn_cast<ConstantDataSequential>(C);
+    auto *CAZ = dyn_cast<ConstantAggregateZero>(C);
+    assert((CDS || CAZ) && "Unsupported ConstantData subclass");
+
+    unsigned NumElems = CDS ? CDS->getNumElements() : CAZ->getNumElements();
+
+    for (unsigned ENum = 0; ENum < NumElems; ++ENum) {
+      Constant *E =
+          CDS ? CDS->getElementAsConstant(ENum) : CAZ->getElementValue(ENum);
+
+      Result.AggregateVal.push_back(getConstantValue(E));
+    }
+    break;
+  }
   case Type::PointerTyID:
     while (auto *A = dyn_cast<GlobalAlias>(C)) {
       C = A->getAliasee();
     }
     if (isa<ConstantPointerNull>(C))
       Result.PointerVal = nullptr;
     else if (const Function *F = dyn_cast<Function>(C))
       Result = PTOGV(getPointerToFunctionOrStub(const_cast<Function*>(F)));

test/ExecutionEngine/Interpreter/constant-aggzero.ll

+; RUN: %lli -force-interpreter %s
+
+define { i32, i32 } @f() {
+  ret { i32, i32 } { i32 0, i32 0 }
+}
+
+define i32 @main() {
+  %s = call { i32, i32 } @f()
+  %t = extractvalue { i32, i32 } %s, 0
+  ret i32 %t
+}

test/ExecutionEngine/Interpreter/constant-array.ll

+; RUN: %lli -force-interpreter %s
+
+define [2 x i32] @f() {
+  ret [2 x i32] [i32 0, i32 1]
+}
+
+define i32 @main() {
+  %a = call [2 x i32] @f()
+  %t = extractvalue [2 x i32] %a, 0
+  ret i32 %t
+}

test/ExecutionEngine/Interpreter/constant-struct.ll

+; RUN: %lli -force-interpreter %s
+
+define { i32, i32 } @f() {
+  ret { i32, i32 } { i32 0, i32 1 }
+}
+
+define i32 @main() {
+  %s = call { i32, i32 } @f()
+  %t = extractvalue { i32, i32 } %s, 0
+  ret i32 %t
+}