D dynamic compilation support

runtime/jit-rt/cpp-so/valueparser.cpp

@@ -0,0 +1,101 @@
+#include "valueparser.h"
+
+#include <cstdint>
+#include <cassert>
+#include <string>
+
+#include "utils.h"
+
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/DataLayout.h"
+
+namespace {
+template<typename T>
+llvm::ConstantInt *getInt(llvm::LLVMContext &context, const void *data) {
+  assert(nullptr != data);
+  const T val = *static_cast<const T*>(data);
+  return llvm::ConstantInt::get(context, llvm::APInt(sizeof(T) * 8, val, true));
+}
+
+template<typename T>
+llvm::ConstantFP *getFloat(llvm::LLVMContext &context, const void *data) {
+  assert(nullptr != data);
+  const T val = *static_cast<const T*>(data);
+  return llvm::ConstantFP::get(context, llvm::APFloat(val));
+}
+
+llvm::Constant *getPtr(llvm::LLVMContext &context,
+                       llvm::Type *targetType,
+                       const void *data) {
+  assert(nullptr != targetType);
+  assert(nullptr != data);
+  const auto val = *static_cast<const uintptr_t*>(data);
+  return llvm::ConstantExpr::getIntToPtr(
+        llvm::ConstantInt::get(context, llvm::APInt(sizeof(val) * 8, val)),
+        targetType);
+}
+}
+
+llvm::Constant *parseInitializer(const Context &context,
+                                 const llvm::DataLayout &dataLayout,
+                                 llvm::Type *type,
+                                 const void *data) {
+  assert(nullptr != type);
+  assert(nullptr != data);
+  auto& llcontext = type->getContext();
+  if (type->isIntegerTy()) {
+    const auto width = type->getIntegerBitWidth();
+    switch (width) {
+    case 8:  return getInt<uint8_t>(llcontext, data);
+    case 16: return getInt<uint16_t>(llcontext, data);
+    case 32: return getInt<uint32_t>(llcontext, data);
+    case 64: return getInt<uint64_t>(llcontext, data);
+    default: fatal(context,
+                   std::string("Invalid int bit width: ") + std::to_string(width));
+    }
+  }
+  if (type->isFloatingPointTy()) {
+    const auto width = type->getPrimitiveSizeInBits();
+    switch (width) {
+    case 32: return getFloat<float>(llcontext, data);
+    case 64: return getFloat<double>(llcontext, data);
+    default: fatal(context,
+                   std::string("Invalid fp bit width: ") + std::to_string(width));
+    }
+  }
+  if (type->isPointerTy()) {
+    return getPtr(llcontext, type, data);
+  }
+  if (type->isStructTy()) {
+    auto stype = llvm::cast<llvm::StructType>(type);
+    auto slayout = dataLayout.getStructLayout(stype);
+    auto numElements = stype->getNumElements();
+    llvm::SmallVector<llvm::Constant*, 16> elements(numElements);
+    for (unsigned i = 0; i < numElements; ++i) {
+      const auto elemType = stype->getElementType(i);
+      const auto elemOffset = slayout->getElementOffset(i);
+      const auto elemPtr = static_cast<const char*>(data) + elemOffset;
+      elements[i] = parseInitializer(context, dataLayout, elemType, elemPtr);
+    }
+    return llvm::ConstantStruct::get(stype, elements);
+  }
+  if (type->isArrayTy()) {
+    auto elemType = type->getArrayElementType();
+    const auto step = dataLayout.getTypeAllocSize(elemType);
+    const auto numElements = type->getArrayNumElements();
+    llvm::SmallVector<llvm::Constant*, 16> elements(numElements);
+    for (uint64_t i = 0; i < numElements; ++i) {
+      const auto elemPtr = static_cast<const char*>(data) + step * i;
+      elements[i] = parseInitializer(context, dataLayout, elemType, elemPtr);
+    }
+    return llvm::ConstantArray::get(llvm::cast<llvm::ArrayType>(type), elements);
+  }
+  std::string tname;
+  llvm::raw_string_ostream os(tname);
+  type->print(os, true);
+  fatal(context, std::string("Unhandled type: ") + os.str());
+  return nullptr;
+}
+