[MLIR][LaunchFuncToVulkan] Remove typed pointer support

mlir/include/mlir/Conversion/Passes.td

@@ -598,12 +598,6 @@ def ConvertVulkanLaunchFuncToVulkanCallsPass
     This pass is only intended for the mlir-vulkan-runner.
   }];
 
-  let options = [
-     Option<"useOpaquePointers", "use-opaque-pointers", "bool",
-            /*default=*/"true", "Generate LLVM IR using opaque pointers "
-            "instead of typed pointers">
-  ];
-
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

@@ -65,11 +65,7 @@ class VulkanLaunchFuncToVulkanCallsPass
   void initializeCachedTypes() {
     llvmFloatType = Float32Type::get(&getContext());
     llvmVoidType = LLVM::LLVMVoidType::get(&getContext());
-    if (useOpaquePointers)
-      llvmPointerType = LLVM::LLVMPointerType::get(&getContext());
-    else
-      llvmPointerType =
-          LLVM::LLVMPointerType::get(IntegerType::get(&getContext(), 8));
+    llvmPointerType = LLVM::LLVMPointerType::get(&getContext());
     llvmInt32Type = IntegerType::get(&getContext(), 32);
     llvmInt64Type = IntegerType::get(&getContext(), 64);
   }
@@ -85,9 +81,6 @@ class VulkanLaunchFuncToVulkanCallsPass
     //   int64_t sizes[Rank]; // omitted when rank == 0
     //   int64_t strides[Rank]; // omitted when rank == 0
     // };
-    auto llvmPtrToElementType = useOpaquePointers
-                                    ? llvmPointerType
-                                    : LLVM::LLVMPointerType::get(elemenType);
     auto llvmArrayRankElementSizeType =
         LLVM::LLVMArrayType::get(getInt64Type(), rank);
 
@@ -96,7 +89,7 @@ class VulkanLaunchFuncToVulkanCallsPass
     // [`rank` x i64], [`rank` x i64]}">`.
     return LLVM::LLVMStructType::getLiteral(
         &getContext(),
-        {llvmPtrToElementType, llvmPtrToElementType, getInt64Type(),
+        {llvmPointerType, llvmPointerType, getInt64Type(),
          llvmArrayRankElementSizeType, llvmArrayRankElementSizeType});
   }
 
@@ -280,13 +273,6 @@ void VulkanLaunchFuncToVulkanCallsPass::createBindMemRefCalls(
 
     auto symbolName =
         llvm::formatv("bindMemRef{0}D{1}", rank, stringifyType(type)).str();
-    // Special case for fp16 type. Since it is not a supported type in C we use
-    // int16_t and bitcast the descriptor.
-    if (!useOpaquePointers && isa<Float16Type>(type)) {
-      auto memRefTy = getMemRefType(rank, IntegerType::get(&getContext(), 16));
-      ptrToMemRefDescriptor = builder.create<LLVM::BitcastOp>(
-          loc, LLVM::LLVMPointerType::get(memRefTy), ptrToMemRefDescriptor);
-    }
     // Create call to `bindMemRef`.
     builder.create<LLVM::CallOp>(
         loc, TypeRange(), StringRef(symbolName.data(), symbolName.size()),
@@ -303,16 +289,9 @@ VulkanLaunchFuncToVulkanCallsPass::deduceMemRefRank(Value launchCallArg,
   if (!alloca)
     return failure();
 
-  LLVM::LLVMStructType llvmDescriptorTy;
-  if (std::optional<Type> elementType = alloca.getElemType()) {
-    llvmDescriptorTy = dyn_cast<LLVM::LLVMStructType>(*elementType);
-  } else {
-    // This case is only possible if we are not using opaque pointers
-    // since opaque pointer producing allocas require an element type.
-    llvmDescriptorTy = dyn_cast<LLVM::LLVMStructType>(
-        alloca.getRes().getType().getElementType());
-  }
-
+  std::optional<Type> elementType = alloca.getElemType();
+  assert(elementType && "expected to work with opaque pointers");
+  auto llvmDescriptorTy = dyn_cast<LLVM::LLVMStructType>(*elementType);
   // template <typename Elem, size_t Rank>
   // struct {
   //   Elem *allocated;
@@ -379,10 +358,7 @@ void VulkanLaunchFuncToVulkanCallsPass::declareVulkanFunctions(Location loc) {
       if (!module.lookupSymbol(fnName)) {
         auto fnType = LLVM::LLVMFunctionType::get(
             getVoidType(),
-            {getPointerType(), getInt32Type(), getInt32Type(),
-             useOpaquePointers
-                 ? llvmPointerType
-                 : LLVM::LLVMPointerType::get(getMemRefType(i, type))},
+            {llvmPointerType, getInt32Type(), getInt32Type(), llvmPointerType},
             /*isVarArg=*/false);
         builder.create<LLVM::LLVMFuncOp>(loc, fnName, fnType);
       }
@@ -410,8 +386,7 @@ Value VulkanLaunchFuncToVulkanCallsPass::createEntryPointNameConstant(
 
   std::string entryPointGlobalName = (name + "_spv_entry_point_name").str();
   return LLVM::createGlobalString(loc, builder, entryPointGlobalName,
-                                  shaderName, LLVM::Linkage::Internal,
-                                  useOpaquePointers);
+                                  shaderName, LLVM::Linkage::Internal);
 }
 
 void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall(
@@ -429,7 +404,7 @@ void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall(
   // that data to runtime call.
   Value ptrToSPIRVBinary = LLVM::createGlobalString(
       loc, builder, kSPIRVBinary, spirvAttributes.blob.getValue(),
-      LLVM::Linkage::Internal, useOpaquePointers);
+      LLVM::Linkage::Internal);
 
   // Create LLVM constant for the size of SPIR-V binary shader.
   Value binarySize = builder.create<LLVM::ConstantOp>(

mlir/test/Conversion/GPUToVulkan/invoke-vulkan.mlir

@@ -1,4 +1,4 @@
-// RUN: mlir-opt %s -launch-func-to-vulkan='use-opaque-pointers=1' | FileCheck %s
+// RUN: mlir-opt %s -launch-func-to-vulkan | FileCheck %s
 
 // CHECK: llvm.mlir.global internal constant @kernel_spv_entry_point_name
 // CHECK: llvm.mlir.global internal constant @SPIRV_BIN