ExecutionEngine: support composite types handling.

[Panzerschrek]

Summary

Now it's possible to load/store composite values (structs, arrays), access constants of composite types, produce undef values of array types.

[Panzerschrek]

https://buildkite.com/llvm-project/diff-checks/builds/148695#0185dfea-0508-46a5-839e-39e609643be2
Unfortunately, the patch build was failed:

INFO
ERROR   <stdin>:62: trailing whitespace.
 
error: lib/ExecutionEngine/ExecutionEngine.cpp: No such file or directory

What exactly went wrong?

[Panzerschrek]

Fix files path - include "llvm" prefix (for monorepo).

[Panzerschrek]

Fix clang-format errors

[Panzerschrek]

Ping

[Panzerschrek]

Comrades, sorry for disturbing, but i need someone to review this PR.

[spatel]

I don't know anything about ExecutionEngine - adding potential reviewers based on the most recent git log entries for this directory.

[Hahnfeld]

As far as I can tell, this is for the MCJIT infrastructure which is deprecated (?) or at least not actively worked on anymore. You should try ORC, which does actual just-in-time compilation.

[Panzerschrek]

In D142386#4166791, @Hahnfeld wrote:

You should try ORC, which does actual just-in-time compilation.

I use interpreter for tests of my programming language. Using interpreter for this is totally fine, JIT is an overkill. Using JIT will slow down tests running. Also compilation will be slower, since JIT depends on code generator libraries (which are huge for x86/x86_64 targets).

[lhames]

@Panzerschrek I don't have a problem with this landing, but want to echo Hahnfeld's point: the interpreter is legacy mode at this point. While there are no immediate plan to remove it, it's not being actively maintained either, and it's possible that it will be removed in a future version (though I would expect us to give a deprecation warning well in advance).

Do you have commit access? If not, please just let me know the name and email that you'd like me to use for attribution and I can commit on your behalf.

• Lang.

[Panzerschrek]

@lhames, after comment of @Hahnfeld i reconsidered usage of ExecutionEngine in my project. I implemented my own version of interpreter and no longer use ExecutionEngine. So, this PR now has no sense. Previously only i needed this functionality, but now nobody needs it.
Let's wait a bit (a couple of month) and if nobody find these changes useful, i will close this PR, otherwise i will merge it.

llvm/lib/ExecutionEngine/ExecutionEngine.cpp

case Type::StructTyID: {
           else if (ElemTy->isAggregateType()) {
               const Constant *ElemUndef = UndefValue::get(ElemTy);
               Result.AggregateVal[i] = getConstantValue(ElemUndef);
             }
           }
         }
       }
       break;
+      case Type::ArrayTyID: {
+        // if the whole array is 'undef' just reserve memory for the value.
+        if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
+          uint64_t elemNum = ATy->getNumElements();
+          Result.AggregateVal.resize(elemNum);
+          Type *ElemTy = ATy->getElementType();
+          for (unsigned int i = 0; i < elemNum; ++i) {
+            if (ElemTy->isIntegerTy())
+              Result.AggregateVal[i].IntVal =
+                  APInt(ElemTy->getPrimitiveSizeInBits(), 0);
+            else if (ElemTy->isAggregateType()) {
+              const Constant *ElemUndef = UndefValue::get(ElemTy);
+              Result.AggregateVal[i] = getConstantValue(ElemUndef);
+            }
+          }
+        }
+      } break;
       case Type::ScalableVectorTyID:
         report_fatal_error(
             "Scalable vector support not yet implemented in ExecutionEngine");
       case Type::FixedVectorTyID:
         // if the whole vector is 'undef' just reserve memory for the value.
         auto *VTy = cast<FixedVectorType>(C->getType());
         Type *ElemTy = VTy->getElementType();
         unsigned int elemNum = VTy->getNumElements();
if (ElemTy->isIntegerTy()) {
             CDV->getElementType()->getPrimitiveSizeInBits(),
             CDV->getElementAsInteger(i));
 
       break;
     }
     llvm_unreachable("Unknown constant pointer type!");
   } break;
 
+  case Type::StructTyID:
+    if (const auto CS = dyn_cast<ConstantStruct>(C)) {
+      Result.AggregateVal.resize(CS->getType()->getNumElements());
+      for (size_t i = 0; i < Result.AggregateVal.size(); ++i)
+        Result.AggregateVal[i] =
+            getConstantValue(CS->getAggregateElement((unsigned int)i));
+      break;
+    }
+    if (const auto CAZ = dyn_cast<ConstantAggregateZero>(C)) {
+      Result.AggregateVal.resize(CAZ->getElementCount().getKnownMinValue());
+      for (size_t i = 0; i < Result.AggregateVal.size(); ++i)
+        Result.AggregateVal[i] =
+            getConstantValue(CAZ->getElementValue((unsigned int)i));
+      break;
+    }
+    llvm_unreachable("Unknown constant struct kind!");
+    break;
+
+  case Type::ArrayTyID:
+    if (const auto CA = dyn_cast<ConstantArray>(C)) {
+      Result.AggregateVal.resize(CA->getType()->getNumElements());
+      for (size_t i = 0; i < Result.AggregateVal.size(); ++i)
+        Result.AggregateVal[i] =
+            getConstantValue(CA->getAggregateElement((unsigned int)i));
+      break;
+    }
+    if (const auto CDA = dyn_cast<ConstantDataArray>(C)) {
+      Result.AggregateVal.resize(CDA->getNumElements());
+      for (size_t i = 0; i < Result.AggregateVal.size(); ++i)
+        Result.AggregateVal[i] =
+            getConstantValue(CDA->getAggregateElement((unsigned int)i));
+      break;
+    }
+    if (const auto CDS = dyn_cast<ConstantDataSequential>(C)) {
+      Result.AggregateVal.resize(CDS->getNumElements());
+      for (size_t i = 0; i < Result.AggregateVal.size(); ++i)
+        Result.AggregateVal[i] =
+            getConstantValue(CDS->getAggregateElement((unsigned int)i));
+      break;
+    }
+    if (const auto CAZ = dyn_cast<ConstantAggregateZero>(C)) {
+      Result.AggregateVal.resize(CAZ->getElementCount().getKnownMinValue());
+      for (size_t i = 0; i < Result.AggregateVal.size(); ++i)
+        Result.AggregateVal[i] =
+            getConstantValue(CAZ->getElementValue((unsigned int)i));
+      break;
+    }
+
+    llvm_unreachable("Unknown constant array kind!");
+    break;
+
   default:
     SmallString<256> Msg;
     raw_svector_ostream OS(Msg);
     OS << "ERROR: Constant unimplemented for type: " << *C->getType();
     report_fatal_error(OS.str());
   }
 
   return Result;
for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
         *(((float*)Ptr)+i) = Val.AggregateVal[i].FloatVal;
       if (cast<VectorType>(Ty)->getElementType()->isIntegerTy()) {
         unsigned numOfBytes =(Val.AggregateVal[i].IntVal.getBitWidth()+7)/8;
         StoreIntToMemory(Val.AggregateVal[i].IntVal,
           (uint8_t*)Ptr + numOfBytes*i, numOfBytes);
       }
     }
     break;
+  case Type::StructTyID: {
+    const auto ST = cast<StructType>(Ty);
+    const unsigned numElems = ST->getNumElements();
+    const StructLayout *const SL = getDataLayout().getStructLayout(ST);
+    assert(Val.AggregateVal.size() == numElems &&
+           "Unexpected number of elements in AggregateVal");
+    for (unsigned i = 0; i < numElems; ++i) {
+      StoreValueToMemory(
+          Val.AggregateVal[i],
+          (GenericValue *)(((uint8_t *)Ptr) + SL->getElementOffset(i)),
+          ST->getElementType(i));
+    }
+  } break;
+  case Type::ArrayTyID: {
+    const auto AT = cast<ArrayType>(Ty);
+    const uint64_t numElems = AT->getNumElements();
+    const auto ET = AT->getElementType();
+    const auto S = getDataLayout().getTypeAllocSize(ET);
+    assert(Val.AggregateVal.size() == numElems &&
+           "Unexpected number of elements in AggregateVal");
+    for (unsigned i = 0; i < numElems; ++i) {
+      StoreValueToMemory(Val.AggregateVal[i],
+                         (GenericValue *)(((uint8_t *)Ptr) + i * S), ET);
+    }
+  } break;
   }
 
   if (sys::IsLittleEndianHost != getDataLayout().isLittleEndian())
     // Host and target are different endian - reverse the stored bytes.
     std::reverse((uint8_t*)Ptr, StoreBytes + (uint8_t*)Ptr);
 }
 
 /// FIXME: document
if (ElemT->isIntegerTy()) {
       intZero.IntVal = APInt(elemBitWidth, 0);
       Result.AggregateVal.resize(numElems, intZero);
       for (unsigned i = 0; i < numElems; ++i)
         LoadIntFromMemory(Result.AggregateVal[i].IntVal,
           (uint8_t*)Ptr+((elemBitWidth+7)/8)*i, (elemBitWidth+7)/8);
     }
   break;
   }
+  case Type::StructTyID: {
+  const auto ST = cast<StructType>(Ty);
+  const unsigned numElems = ST->getNumElements();
+  const StructLayout *const SL = getDataLayout().getStructLayout(ST);
+  Result.AggregateVal.resize(numElems);
+  for (unsigned i = 0; i < numElems; ++i) {
+      LoadValueFromMemory(
+          Result.AggregateVal[i],
+          (GenericValue *)(((uint8_t *)Ptr) + SL->getElementOffset(i)),
+          ST->getElementType(i));
+  }
+  } break;
+  case Type::ArrayTyID: {
+  const auto AT = cast<ArrayType>(Ty);
+  const uint64_t numElems = AT->getNumElements();
+  const auto ET = AT->getElementType();
+  const auto S = getDataLayout().getTypeAllocSize(ET);
+  Result.AggregateVal.resize(numElems);
+  for (unsigned i = 0; i < numElems; ++i) {
+      LoadValueFromMemory(Result.AggregateVal[i],
+                          (GenericValue *)(((uint8_t *)Ptr) + i * S), ET);
+  }
+  } break;
   default:
     SmallString<256> Msg;
     raw_svector_ostream OS(Msg);
     OS << "Cannot load value of type " << *Ty << "!";
     report_fatal_error(OS.str());
   }
 }
 

llvm/test/ExecutionEngine/Interpreter/composite-load-store.ll

+; RUN: %lli -jit-kind=mcjit -force-interpreter %s
+
+%"SomeStruct" = type { i1, [ 2 x i32 ], double }
+
+define void @load_test()
+{
+  %s_ptr = alloca %"SomeStruct"
+
+  ; Store separate elements.
+  %s_ptr.0 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 0
+  %s_ptr.1.0 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 1, i32 0
+  %s_ptr.1.1 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 1, i32 1
+  %s_ptr.2 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 2
+
+  store i1 true, ptr %s_ptr.0
+  store i32 10, ptr %s_ptr.1.0
+  store i32 20, ptr %s_ptr.1.1
+  store double 3.14, ptr %s_ptr.2
+
+  ; Load whole struct.
+  %s = load %"SomeStruct", ptr %s_ptr
+
+  ; Extract separate elements.
+  %s.0 = extractvalue %"SomeStruct" %s, 0
+  %s.1.0 = extractvalue %"SomeStruct" %s, 1, 0
+  %s.1.1 = extractvalue %"SomeStruct" %s, 1, 1
+  %s.2 = extractvalue %"SomeStruct" %s, 2
+
+  ; Compare extracted values with expected.
+  %s_cmp.0 = icmp eq i1 %s.0, true
+  %s_cmp.1.0 = icmp eq i32 %s.1.0, 10
+  %s_cmp.1.1 = icmp eq i32 %s.1.1, 20
+  %s_cmp.2 = fcmp oeq double %s.2, 3.14
+
+  ; Break to error label if extracted value is unexpected.
+  br i1 %s_cmp.0, label %s_cmp_ok.0, label %on_error
+s_cmp_ok.0:
+
+  br i1 %s_cmp.1.0, label %s_cmp_ok.1.0, label %on_error
+s_cmp_ok.1.0:
+
+  br i1 %s_cmp.1.1, label %s_cmp_ok.1.1, label %on_error
+s_cmp_ok.1.1:
+
+  br i1 %s_cmp.2, label %s_cmp_ok.2, label %on_error
+s_cmp_ok.2:
+
+  ret void
+
+on_error:
+  unreachable
+}
+
+define void @store_test()
+{
+  %s_ptr = alloca %"SomeStruct"
+  
+  ; Store some constant as whole.
+  store %"SomeStruct"{ i1 true, [ 2 x i32 ] [ i32 10, i32 20 ], double 3.14 }, ptr %s_ptr
+
+  ; Load elements of stored value.
+  %s_ptr.0 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 0
+  %s_ptr.1.0 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 1, i32 0
+  %s_ptr.1.1 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 1, i32 1
+  %s_ptr.2 = getelementptr %"SomeStruct", ptr %s_ptr, i32 0, i32 2
+
+  %s.0 = load i1, ptr %s_ptr.0
+  %s.1.0 = load i32, ptr %s_ptr.1.0
+  %s.1.1 = load i32, ptr %s_ptr.1.1
+  %s.2 = load double, ptr %s_ptr.2
+
+  ; Compare loaded values with expected.
+  %s_cmp.0 = icmp eq i1 %s.0, true
+  %s_cmp.1.0 = icmp eq i32 %s.1.0, 10
+  %s_cmp.1.1 = icmp eq i32 %s.1.1, 20
+  %s_cmp.2 = fcmp oeq double %s.2, 3.14
+
+  ; Break to error label if loaded value is unexpected.
+  br i1 %s_cmp.0, label %s_cmp_ok.0, label %on_error
+s_cmp_ok.0:
+
+  br i1 %s_cmp.1.0, label %s_cmp_ok.1.0, label %on_error
+s_cmp_ok.1.0:
+
+  br i1 %s_cmp.1.1, label %s_cmp_ok.1.1, label %on_error
+s_cmp_ok.1.1:
+
+  br i1 %s_cmp.2, label %s_cmp_ok.2, label %on_error
+s_cmp_ok.2:
+
+  ret void
+
+on_error:
+  unreachable
+}
+
+define i32 @main()
+{
+  call void @load_test()
+  call void @store_test()
+  ret i32 0
+}