Revert "[CIR] Function type return type improvements (llvm#128787)"

This reverts commit 556eb82.

Author: lanza

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -365,6 +365,12 @@ def FuncOp : CIR_Op<"func", [
        return getFunctionType().getReturnTypes();
     }
 
+    /// Hook for OpTrait::FunctionOpInterfaceTrait, called after verifying that
+    /// the 'type' attribute is present and checks if it holds a function type.
+    /// Ensures getType, getNumFuncArguments, and getNumFuncResults can be
+    /// called safely.
+    llvm::LogicalResult verifyType();
+
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//

clang/include/clang/CIR/Dialect/IR/CIRTypes.td

@@ -287,44 +287,32 @@ def CIR_BoolType :
 def CIR_FuncType : CIR_Type<"Func", "func"> {
   let summary = "CIR function type";
   let description = [{
-    The `!cir.func` is a function type. It consists of an optional return type,
-    a list of parameter types and can optionally be variadic.
+    The `!cir.func` is a function type. It consists of a single return type, a
+    list of parameter types and can optionally be variadic.
 
     Example:
 
     ```mlir
-    !cir.func<()>
-    !cir.func<() -> bool>
-    !cir.func<(!s8i, !s8i)>
-    !cir.func<(!s8i, !s8i) -> !s32i>
-    !cir.func<(!s32i, ...) -> !s32i>
+    !cir.func<!bool ()>
+    !cir.func<!s32i (!s8i, !s8i)>
+    !cir.func<!s32i (!s32i, ...)>
     ```
   }];
 
   let parameters = (ins ArrayRefParameter<"mlir::Type">:$inputs,
-                        OptionalParameter<"mlir::Type">:$optionalReturnType,
-                        "bool":$varArg);
-  // Use a custom parser to handle argument types with variadic elipsis.
+                        "mlir::Type":$returnType, "bool":$varArg);
   let assemblyFormat = [{
-    `<` custom<FuncTypeParams>($inputs, $varArg)  (`->` $optionalReturnType^)? `>`
+    `<` $returnType ` ` `(` custom<FuncTypeArgs>($inputs, $varArg) `>`
   }];
 
   let builders = [
-    // Create a FuncType, converting the return type from C-style to
-    // MLIR-style.  If the given return type is `cir::VoidType`, ignore it
-    // and create the FuncType with no return type, which is how MLIR
-    // represents function types.
     TypeBuilderWithInferredContext<(ins
       "llvm::ArrayRef<mlir::Type>":$inputs, "mlir::Type":$returnType,
       CArg<"bool", "false">:$isVarArg), [{
-        return $_get(returnType.getContext(), inputs,
-                     mlir::isa<cir::VoidType>(returnType) ? nullptr : returnType,
-                     isVarArg);
+      return $_get(returnType.getContext(), inputs, returnType, isVarArg);
     }]>
   ];
 
-  let genVerifyDecl = 1;
-
   let extraClassDeclaration = [{
     /// Returns whether the function is variadic.
     bool isVarArg() const { return getVarArg(); }
@@ -335,17 +323,12 @@ def CIR_FuncType : CIR_Type<"Func", "func"> {
     /// Returns the number of arguments to the function.
     unsigned getNumInputs() const { return getInputs().size(); }
 
-    /// Get the C-style return type of the function, which is !cir.void if the
-    /// function returns nothing and the actual return type otherwise.
-    mlir::Type getReturnType() const;
-
-    /// Get the MLIR-style return type of the function, which is an empty
-    /// ArrayRef if the function returns nothing and a single-element ArrayRef
-    /// with the actual return type otherwise.
+    /// Returns the result type of the function as an ArrayRef, enabling better
+    /// integration with generic MLIR utilities.
     llvm::ArrayRef<mlir::Type> getReturnTypes() const;
 
-    /// Does the function type return nothing?
-    bool hasVoidReturn() const;
+    /// Returns whether the function is returns void.
+    bool isVoid() const;
 
     /// Returns a clone of this function type with the given argument
     /// and result types.

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -60,7 +60,7 @@ bool CIRGenTypes::isFuncTypeConvertible(const FunctionType *ft) {
 mlir::Type CIRGenTypes::convertFunctionTypeInternal(QualType qft) {
   assert(qft.isCanonical());
   const FunctionType *ft = cast<FunctionType>(qft.getTypePtr());
-  // First, check whether we can build the full function type. If the function
+  // First, check whether we can build the full fucntion type. If the function
   // type depends on an incomplete type (e.g. a struct or enum), we cannot lower
   // the function type.
   if (!isFuncTypeConvertible(ft)) {

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -416,6 +416,17 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
   }
 }
 
+// Hook for OpTrait::FunctionLike, called after verifying that the 'type'
+// attribute is present.  This can check for preconditions of the
+// getNumArguments hook not failing.
+LogicalResult cir::FuncOp::verifyType() {
+  auto type = getFunctionType();
+  if (!isa<cir::FuncType>(type))
+    return emitOpError("requires '" + getFunctionTypeAttrName().str() +
+                       "' attribute of function type");
+  return success();
+}
+
 // TODO(CIR): The properties of functions that require verification haven't
 // been implemented yet.
 mlir::LogicalResult cir::FuncOp::verify() { return success(); }

clang/lib/CIR/Dialect/IR/CIRTypes.cpp

@@ -21,11 +21,10 @@
 //===----------------------------------------------------------------------===//
 
 static mlir::ParseResult
-parseFuncTypeParams(mlir::AsmParser &p, llvm::SmallVector<mlir::Type> &params,
-                    bool &isVarArg);
-static void printFuncTypeParams(mlir::AsmPrinter &p,
-                                mlir::ArrayRef<mlir::Type> params,
-                                bool isVarArg);
+parseFuncTypeArgs(mlir::AsmParser &p, llvm::SmallVector<mlir::Type> &params,
+                  bool &isVarArg);
+static void printFuncTypeArgs(mlir::AsmPrinter &p,
+                              mlir::ArrayRef<mlir::Type> params, bool isVarArg);
 
 //===----------------------------------------------------------------------===//
 // Get autogenerated stuff
@@ -283,32 +282,40 @@ FuncType FuncType::clone(TypeRange inputs, TypeRange results) const {
   return get(llvm::to_vector(inputs), results[0], isVarArg());
 }
 
-// Custom parser that parses function parameters of form `(<type>*, ...)`.
-static mlir::ParseResult
-parseFuncTypeParams(mlir::AsmParser &p, llvm::SmallVector<mlir::Type> &params,
-                    bool &isVarArg) {
+mlir::ParseResult parseFuncTypeArgs(mlir::AsmParser &p,
+                                    llvm::SmallVector<mlir::Type> &params,
+                                    bool &isVarArg) {
   isVarArg = false;
-  return p.parseCommaSeparatedList(
-      AsmParser::Delimiter::Paren, [&]() -> mlir::ParseResult {
-        if (isVarArg)
-          return p.emitError(p.getCurrentLocation(),
-                             "variadic `...` must be the last parameter");
-        if (succeeded(p.parseOptionalEllipsis())) {
-          isVarArg = true;
-          return success();
-        }
-        mlir::Type type;
-        if (failed(p.parseType(type)))
-          return failure();
-        params.push_back(type);
-        return success();
-      });
-}
-
-static void printFuncTypeParams(mlir::AsmPrinter &p,
-                                mlir::ArrayRef<mlir::Type> params,
-                                bool isVarArg) {
-  p << '(';
+  // `(` `)`
+  if (succeeded(p.parseOptionalRParen()))
+    return mlir::success();
+
+  // `(` `...` `)`
+  if (succeeded(p.parseOptionalEllipsis())) {
+    isVarArg = true;
+    return p.parseRParen();
+  }
+
+  // type (`,` type)* (`,` `...`)?
+  mlir::Type type;
+  if (p.parseType(type))
+    return mlir::failure();
+  params.push_back(type);
+  while (succeeded(p.parseOptionalComma())) {
+    if (succeeded(p.parseOptionalEllipsis())) {
+      isVarArg = true;
+      return p.parseRParen();
+    }
+    if (p.parseType(type))
+      return mlir::failure();
+    params.push_back(type);
+  }
+
+  return p.parseRParen();
+}
+
+void printFuncTypeArgs(mlir::AsmPrinter &p, mlir::ArrayRef<mlir::Type> params,
+                       bool isVarArg) {
   llvm::interleaveComma(params, p,
                         [&p](mlir::Type type) { p.printType(type); });
   if (isVarArg) {
@@ -319,39 +326,11 @@ static void printFuncTypeParams(mlir::AsmPrinter &p,
   p << ')';
 }
 
-/// Get the C-style return type of the function, which is !cir.void if the
-/// function returns nothing and the actual return type otherwise.
-mlir::Type FuncType::getReturnType() const {
-  if (hasVoidReturn())
-    return cir::VoidType::get(getContext());
-  return getOptionalReturnType();
-}
-
-/// Get the MLIR-style return type of the function, which is an empty
-/// ArrayRef if the function returns nothing and a single-element ArrayRef
-/// with the actual return type otherwise.
 llvm::ArrayRef<mlir::Type> FuncType::getReturnTypes() const {
-  if (hasVoidReturn())
-    return {};
-  // Can't use getOptionalReturnType() here because llvm::ArrayRef hold a
-  // pointer to its elements and doesn't do lifetime extension.  That would
-  // result in returning a pointer to a temporary that has gone out of scope.
-  return getImpl()->optionalReturnType;
+  return static_cast<detail::FuncTypeStorage *>(getImpl())->returnType;
 }
 
-// Does the fuction type return nothing?
-bool FuncType::hasVoidReturn() const { return !getOptionalReturnType(); }
-
-mlir::LogicalResult
-FuncType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
-                 llvm::ArrayRef<mlir::Type> argTypes, mlir::Type returnType,
-                 bool isVarArg) {
-  if (returnType && mlir::isa<cir::VoidType>(returnType)) {
-    emitError() << "!cir.func cannot have an explicit 'void' return type";
-    return mlir::failure();
-  }
-  return mlir::success();
-}
+bool FuncType::isVoid() const { return mlir::isa<VoidType>(getReturnType()); }
 
 //===----------------------------------------------------------------------===//
 // BoolType

clang/test/CIR/IR/func.cir

@@ -2,18 +2,18 @@
 
 module {
 // void empty() { }
-cir.func @empty() {
+cir.func @empty() -> !cir.void {
   cir.return
 }
-// CHECK: cir.func @empty() {
+// CHECK: cir.func @empty() -> !cir.void {
 // CHECK:   cir.return
 // CHECK: }
 
 // void voidret() { return; }
-cir.func @voidret() {
+cir.func @voidret() -> !cir.void {
   cir.return
 }
-// CHECK: cir.func @voidret() {
+// CHECK: cir.func @voidret() -> !cir.void {
 // CHECK:   cir.return
 // CHECK: }
 

clang/test/CIR/IR/global.cir

@@ -30,9 +30,9 @@ module attributes {cir.triple = "x86_64-unknown-linux-gnu"} {
   cir.global @ip = #cir.ptr<null> : !cir.ptr<!cir.int<s, 32>>
   cir.global @dp : !cir.ptr<!cir.double>
   cir.global @cpp : !cir.ptr<!cir.ptr<!cir.int<s, 8>>>
-  cir.global @fp : !cir.ptr<!cir.func<()>>
-  cir.global @fpii = #cir.ptr<null> : !cir.ptr<!cir.func<(!cir.int<s, 32>) -> !cir.int<s, 32>>>
-  cir.global @fpvar : !cir.ptr<!cir.func<(!cir.int<s, 32>, ...)>>
+  cir.global @fp : !cir.ptr<!cir.func<!cir.void ()>>
+  cir.global @fpii = #cir.ptr<null> : !cir.ptr<!cir.func<!cir.int<s, 32> (!cir.int<s, 32>)>>
+  cir.global @fpvar : !cir.ptr<!cir.func<!cir.void (!cir.int<s, 32>, ...)>>
 }
 
 // CHECK: cir.global @c : !cir.int<s, 8>
@@ -64,6 +64,6 @@ module attributes {cir.triple = "x86_64-unknown-linux-gnu"} {
 // CHECK: cir.global @ip = #cir.ptr<null> : !cir.ptr<!cir.int<s, 32>>
 // CHECK: cir.global @dp : !cir.ptr<!cir.double>
 // CHECK: cir.global @cpp : !cir.ptr<!cir.ptr<!cir.int<s, 8>>>
-// CHECK: cir.global @fp : !cir.ptr<!cir.func<()>>
-// CHECK: cir.global @fpii = #cir.ptr<null> : !cir.ptr<!cir.func<(!cir.int<s, 32>) -> !cir.int<s, 32>>>
-// CHECK: cir.global @fpvar : !cir.ptr<!cir.func<(!cir.int<s, 32>, ...)>>
+// CHECK: cir.global @fp : !cir.ptr<!cir.func<!cir.void ()>>
+// CHECK: cir.global @fpii = #cir.ptr<null> : !cir.ptr<!cir.func<!cir.int<s, 32> (!cir.int<s, 32>)>>
+// CHECK: cir.global @fpvar : !cir.ptr<!cir.func<!cir.void (!cir.int<s, 32>, ...)>>

clang/test/CIR/func-simple.cpp

@@ -2,12 +2,12 @@
 // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o -  | FileCheck %s
 
 void empty() { }
-// CHECK: cir.func @empty() {
+// CHECK: cir.func @empty() -> !cir.void {
 // CHECK:   cir.return
 // CHECK: }
 
 void voidret() { return; }
-// CHECK: cir.func @voidret() {
+// CHECK: cir.func @voidret() -> !cir.void {
 // CHECK:   cir.return
 // CHECK: }
 

clang/test/CIR/global-var-simple.cpp

@@ -92,10 +92,10 @@ char **cpp;
 // CHECK: cir.global @cpp : !cir.ptr<!cir.ptr<!cir.int<s, 8>>>
 
 void (*fp)();
-// CHECK: cir.global @fp : !cir.ptr<!cir.func<()>>
+// CHECK: cir.global @fp : !cir.ptr<!cir.func<!cir.void ()>>
 
 int (*fpii)(int) = 0;
-// CHECK: cir.global @fpii = #cir.ptr<null> : !cir.ptr<!cir.func<(!cir.int<s, 32>) -> !cir.int<s, 32>>>
+// CHECK: cir.global @fpii = #cir.ptr<null> : !cir.ptr<!cir.func<!cir.int<s, 32> (!cir.int<s, 32>)>>
 
 void (*fpvar)(int, ...);
-// CHECK: cir.global @fpvar : !cir.ptr<!cir.func<(!cir.int<s, 32>, ...)>>
+// CHECK: cir.global @fpvar : !cir.ptr<!cir.func<!cir.void (!cir.int<s, 32>, ...)>>