[MLIR][LLVM] Don't use void return type in MLIR APIs.

In the LLVM IR dialect, `LLVMVoidType` is used to model the return type
of LLVM IR functions with no return value. This is inconsistent with
MLIR APIs, which expect a function with no return value to have an
empty return type. Handle this special case in `LLVMFuncOp` to avoid
mismatches between the number of return values and return types between
caller and callee.

The parser of `LLVMFuncOp` is adapted to be symmetric with the printer,
and not allow `!llvm.void` to be expressed explicitly as a return type
in the IR, thus avoiding to expose this implementation detail.

Differential Revision: https://reviews.llvm.org/D141676

Author: definelicht

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

@@ -1514,14 +1514,18 @@ def LLVM_LLVMFuncOp : LLVM_Op<"func", [
     ArrayRef<Type> getArgumentTypes() { return getFunctionType().getParams(); }
 
     /// Returns the result types of this function.
-    ArrayRef<Type> getResultTypes() { return getFunctionType().getReturnTypes(); }
+    ArrayRef<Type> getResultTypes() {
+      if (getFunctionType().getReturnType().isa<LLVM::LLVMVoidType>())
+        return {};
+      return getFunctionType().getReturnTypes();
+    }
 
     /// Returns the callable region, which is the function body. If the function
     /// is external, returns null.
     Region *getCallableRegion();
 
     /// Returns the callable result type, which is the function return type.
-    ArrayRef<Type> getCallableResults() { return getFunctionType().getReturnTypes(); }
+    ArrayRef<Type> getCallableResults() { return getResultTypes(); }
 
   }];
 

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

@@ -2044,7 +2044,16 @@ buildLLVMFunctionType(OpAsmParser &parser, SMLoc loc, ArrayRef<Type> inputs,
     llvmInputs.push_back(t);
   }
 
-  // No output is denoted as "void" in LLVM type system.
+  // The void return type is an internal implementation detail that should not
+  // be expressed explicitly on the IR. This is symmetric to the printer, which
+  // does not print the implicit void return type.
+  if (!outputs.empty() && outputs.front().isa<LLVMVoidType>()) {
+    parser.emitError(loc, "failed to construct function type: void return type "
+                          "should not be passed explicitly");
+    return {};
+  }
+
+  // Set implicit void type to represent no return value.
   Type llvmOutput =
       outputs.empty() ? LLVMVoidType::get(b.getContext()) : outputs.front();
   if (!isCompatibleType(llvmOutput)) {

mlir/test/Dialect/LLVMIR/func.mlir

@@ -256,8 +256,8 @@ module {
 // -----
 
 module {
-  // expected-error@+1 {{cannot attach result attributes to functions with a void return}}
-  llvm.func @variadic_def() -> (!llvm.void {llvm.noundef})
+  // expected-error@+1 {{void return type should not be passed explicitly}}
+  llvm.func @variadic_def() -> (!llvm.void)
 }
 
 // -----

mlir/test/Target/LLVMIR/llvmir-types.mlir

@@ -5,7 +5,7 @@
 //
 
 // CHECK: declare void @return_void()
-llvm.func @return_void() -> !llvm.void
+llvm.func @return_void()
 // CHECK: declare half @return_half()
 llvm.func @return_half() -> f16
 // CHECK: declare bfloat @return_bfloat()
@@ -28,7 +28,7 @@ llvm.func @return_x86_mmx() -> !llvm.x86_mmx
 //
 
 // CHECK: declare void @f_void_i32(i32)
-llvm.func @f_void_i32(i32) -> !llvm.void
+llvm.func @f_void_i32(i32)
 // CHECK: declare i32 @f_i32_empty()
 llvm.func @f_i32_empty() -> i32
 // CHECK: declare i32 @f_i32_half_bfloat_float_double(half, bfloat, float, double)