Function toLLVMConstantZero

lib/llvm/compiler.cpp:500–538

}

static LLVM::Value toLLVMConstantZero(
    LLVM::Context LLContext, const ValType &ValType,
    Span<const AST::CompositeType *const> CompositeTypes) noexcept {
  switch (ValType.getCode()) {
  case TypeCode::I32:
    return LLVM::Value::getConstNull(LLContext.getInt32Ty());
  case TypeCode::I64:
    return LLVM::Value::getConstNull(LLContext.getInt64Ty());
  case TypeCode::Ref:
  case TypeCode::RefNull: {
    std::array<uint8_t, 16> Data{};
    if (ValType.isAbsHeapType()) {
      // Abstract heap types are already fine for null refs.
      const auto Raw = ValType.getRawData();
      std::copy(Raw.begin(), Raw.end(), Data.begin());
    } else {
      // For non-abstract heap types (concrete type indices), convert to the
      // abstract heap type so that ref.cast/ref.test won't dereference a null
      // pointer when checking the type.
      assuming(ValType.getTypeIndex() < CompositeTypes.size());
      const auto *CompType = CompositeTypes[ValType.getTypeIndex()];
      assuming(CompType != nullptr);
      WasmEdge::ValType VType =
          CompType->isFunc() ? TypeCode::NullFuncRef : TypeCode::NullRef;
      std::copy_n(VType.getRawData().cbegin(), 8, Data.begin());
    }
    return LLVM::Value::getConstVector8(LLContext, Data);
  }
  case TypeCode::V128:
    return LLVM::Value::getConstNull(
        LLVM::Type::getVectorType(LLContext.getInt64Ty(), 2));
  case TypeCode::F32:
    return LLVM::Value::getConstNull(LLContext.getFloatTy());
  case TypeCode::F64:
    return LLVM::Value::getConstNull(LLContext.getDoubleTy());
  default:
    assumingUnreachable();
  }
}

class FunctionCompiler {
  struct Control;