[CIR][Dialect][Lowering] Add calling convention attribute to FuncOp (#760)

This PR simply adds the calling convention attribute to FuncOp with LLVM
Lowering support.

The overall approach follows `GlobalLinkageKind`: Extend the ODS,
parser, printer and lowering pass. When the call conv is C call conv,
it's omitted in the output assembly.

---------

Co-authored-by: Bruno Cardoso Lopes <[email protected]>

Author: 2 people

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

@@ -2794,6 +2794,19 @@ def BaseClassAddrOp : CIR_Op<"base_class_addr"> {
 // FuncOp
 //===----------------------------------------------------------------------===//
 
+// The enumeration values are not necessarily in sync with `clang::CallingConv`
+// or `llvm::CallingConv`.
+def CC_C : I32EnumAttrCase<"C", 1, "c">;
+def CC_SpirKernel : I32EnumAttrCase<"SpirKernel", 2, "spir_kernel">;
+def CC_SpirFunction : I32EnumAttrCase<"SpirFunction", 3, "spir_function">;
+
+def CallingConv : I32EnumAttr<
+    "CallingConv",
+    "calling convention",
+    [CC_C, CC_SpirKernel, CC_SpirFunction]> {
+  let cppNamespace = "::mlir::cir";
+}
+
 def FuncOp : CIR_Op<"func", [
   AutomaticAllocationScope, CallableOpInterface, FunctionOpInterface,
   DeclareOpInterfaceMethods<CIRGlobalValueInterface>,
@@ -2819,6 +2832,9 @@ def FuncOp : CIR_Op<"func", [
     The function linkage information is specified by `linkage`, as defined by
     `GlobalLinkageKind` attribute.
 
+    The `calling_conv` attribute specifies the calling convention of the function.
+    The default calling convention is `CallingConv::C`.
+
     A compiler builtin function must be marked as `builtin` for further
     processing when lowering from CIR.
 
@@ -2857,6 +2873,9 @@ def FuncOp : CIR_Op<"func", [
     // Linkage information
     cir.func linkonce_odr @some_method(...)
 
+    // Calling convention information
+    cir.func @another_func(...) cc(spir_kernel) extra(#fn_attr)
+
     // Builtin function
     cir.func builtin @__builtin_coro_end(!cir.ptr<i8>, !cir.bool) -> !cir.bool
 
@@ -2878,6 +2897,8 @@ def FuncOp : CIR_Op<"func", [
                        UnitAttr:$dsolocal,
                        DefaultValuedAttr<GlobalLinkageKind,
                                          "GlobalLinkageKind::ExternalLinkage">:$linkage,
+                       DefaultValuedAttr<CallingConv,
+                                         "CallingConv::C">:$calling_conv,
                        ExtraFuncAttr:$extra_attrs,
                        OptionalAttr<StrAttr>:$sym_visibility,
                        UnitAttr:$comdat,
@@ -2893,6 +2914,7 @@ def FuncOp : CIR_Op<"func", [
   let builders = [OpBuilder<(ins
     "StringRef":$name, "FuncType":$type,
     CArg<"GlobalLinkageKind", "GlobalLinkageKind::ExternalLinkage">:$linkage,
+    CArg<"CallingConv", "CallingConv::C">:$callingConv,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
     CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
   >];

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

@@ -157,6 +157,7 @@ template <typename Ty> struct EnumTraits {};
   }
 
 REGISTER_ENUM_TYPE(GlobalLinkageKind);
+REGISTER_ENUM_TYPE(CallingConv);
 REGISTER_ENUM_TYPE_WITH_NS(sob, SignedOverflowBehavior);
 } // namespace
 
@@ -176,6 +177,20 @@ static RetTy parseOptionalCIRKeyword(AsmParser &parser, EnumTy defaultValue) {
   return static_cast<RetTy>(index);
 }
 
+/// Parse an enum from the keyword, return failure if the keyword is not found.
+template <typename EnumTy, typename RetTy = EnumTy>
+static ParseResult parseCIRKeyword(AsmParser &parser, RetTy &result) {
+  SmallVector<StringRef, 10> names;
+  for (unsigned i = 0, e = EnumTraits<EnumTy>::getMaxEnumVal(); i <= e; ++i)
+    names.push_back(EnumTraits<EnumTy>::stringify(static_cast<EnumTy>(i)));
+
+  int index = parseOptionalKeywordAlternative(parser, names);
+  if (index == -1)
+    return failure();
+  result = static_cast<RetTy>(index);
+  return success();
+}
+
 // Check if a region's termination omission is valid and, if so, creates and
 // inserts the omitted terminator into the region.
 LogicalResult ensureRegionTerm(OpAsmParser &parser, Region &region,
@@ -1874,7 +1889,7 @@ static StringRef getLinkageAttrNameString() { return "linkage"; }
 
 void cir::FuncOp::build(OpBuilder &builder, OperationState &result,
                         StringRef name, cir::FuncType type,
-                        GlobalLinkageKind linkage,
+                        GlobalLinkageKind linkage, CallingConv callingConv,
                         ArrayRef<NamedAttribute> attrs,
                         ArrayRef<DictionaryAttr> argAttrs) {
   result.addRegion();
@@ -1885,6 +1900,8 @@ void cir::FuncOp::build(OpBuilder &builder, OperationState &result,
   result.addAttribute(
       getLinkageAttrNameString(),
       GlobalLinkageKindAttr::get(builder.getContext(), linkage));
+  result.addAttribute(getCallingConvAttrName(result.name),
+                      CallingConvAttr::get(builder.getContext(), callingConv));
   result.attributes.append(attrs.begin(), attrs.end());
   if (argAttrs.empty())
     return;
@@ -1991,6 +2008,20 @@ ParseResult cir::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
     hasAlias = true;
   }
 
+  // Default to C calling convention if no keyword is provided.
+  auto callConvNameAttr = getCallingConvAttrName(state.name);
+  CallingConv callConv = CallingConv::C;
+  if (parser.parseOptionalKeyword("cc").succeeded()) {
+    if (parser.parseLParen().failed())
+      return failure();
+    if (parseCIRKeyword<CallingConv>(parser, callConv).failed())
+      return parser.emitError(loc) << "unknown calling convention";
+    if (parser.parseRParen().failed())
+      return failure();
+  }
+  state.addAttribute(callConvNameAttr,
+                     CallingConvAttr::get(parser.getContext(), callConv));
+
   auto parseGlobalDtorCtor =
       [&](StringRef keyword,
           llvm::function_ref<void(std::optional<int> prio)> createAttr)
@@ -2144,6 +2175,7 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
           getGlobalDtorAttrName(),
           getLambdaAttrName(),
           getLinkageAttrName(),
+          getCallingConvAttrName(),
           getNoProtoAttrName(),
           getSymVisibilityAttrName(),
           getArgAttrsAttrName(),
@@ -2157,6 +2189,12 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
     p << ")";
   }
 
+  if (getCallingConv() != CallingConv::C) {
+    p << " cc(";
+    p << stringifyCallingConv(getCallingConv());
+    p << ")";
+  }
+
   if (auto globalCtor = getGlobalCtorAttr()) {
     p << " global_ctor";
     if (!globalCtor.isDefaultPriority())

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -463,6 +463,22 @@ mlir::LLVM::Linkage convertLinkage(mlir::cir::GlobalLinkageKind linkage) {
   };
 }
 
+mlir::LLVM::CConv convertCallingConv(mlir::cir::CallingConv callinvConv) {
+  using CIR = mlir::cir::CallingConv;
+  using LLVM = mlir::LLVM::CConv;
+
+  switch (callinvConv) {
+  case CIR::C:
+    return LLVM::C;
+  case CIR::SpirKernel:
+    return LLVM::SPIR_KERNEL;
+  case CIR::SpirFunction:
+    return LLVM::SPIR_FUNC;
+  default:
+    llvm_unreachable("Unknown calling convention");
+  }
+}
+
 class CIRCopyOpLowering : public mlir::OpConversionPattern<mlir::cir::CopyOp> {
 public:
   using mlir::OpConversionPattern<mlir::cir::CopyOp>::OpConversionPattern;
@@ -1528,6 +1544,7 @@ class CIRFuncLowering : public mlir::OpConversionPattern<mlir::cir::FuncOp> {
       if (attr.getName() == mlir::SymbolTable::getSymbolAttrName() ||
           attr.getName() == func.getFunctionTypeAttrName() ||
           attr.getName() == getLinkageAttrNameString() ||
+          attr.getName() == func.getCallingConvAttrName() ||
           (filterArgAndResAttrs &&
            (attr.getName() == func.getArgAttrsAttrName() ||
             attr.getName() == func.getResAttrsAttrName())))
@@ -1613,11 +1630,12 @@ class CIRFuncLowering : public mlir::OpConversionPattern<mlir::cir::FuncOp> {
            "expected single location or unknown location here");
 
     auto linkage = convertLinkage(op.getLinkage());
+    auto cconv = convertCallingConv(op.getCallingConv());
     SmallVector<mlir::NamedAttribute, 4> attributes;
     lowerFuncAttributes(op, /*filterArgAndResAttrs=*/false, attributes);
 
     auto fn = rewriter.create<mlir::LLVM::LLVMFuncOp>(
-        Loc, op.getName(), llvmFnTy, linkage, isDsoLocal, mlir::LLVM::CConv::C,
+        Loc, op.getName(), llvmFnTy, linkage, isDsoLocal, cconv,
         mlir::SymbolRefAttr(), attributes);
 
     rewriter.inlineRegionBefore(op.getBody(), fn.getBody(), fn.end());

clang/test/CIR/IR/func-call-conv.cir

@@ -0,0 +1,27 @@
+// RUN: cir-opt %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+!s32i = !cir.int<s, 32>
+
+#fn_attr = #cir<extra({inline = #cir.inline<no>})>
+
+module {
+    // CHECK: cir.func @foo() {
+    cir.func @foo() cc(c) {
+        cir.return
+    }
+
+    // CHECK: cir.func @bar() cc(spir_kernel)
+    cir.func @bar() cc(spir_kernel) {
+        cir.return
+    }
+
+    // CHECK: cir.func @bar_alias() alias(@bar) cc(spir_kernel)
+    cir.func @bar_alias() alias(@bar) cc(spir_kernel)
+
+    // CHECK: cir.func @baz() cc(spir_function) extra(#fn_attr)
+    cir.func @baz() cc(spir_function) extra(#fn_attr) {
+        cir.return
+    }
+}
+

clang/test/CIR/IR/invalid.cir

@@ -1262,3 +1262,13 @@ cir.func @address_space4(%p : !cir.ptr<!u64i, addrspace(foobar)>) { // expected-
   type_qual = [""],
   name = ["foo"]
 >
+
+// -----
+
+module {
+    // expected-error@+1 {{unknown calling convention}}
+    cir.func @foo() cc(foobar) {
+        cir.return
+    }
+}
+

clang/test/CIR/Lowering/func-call-conv.cir

@@ -0,0 +1,20 @@
+// RUN: cir-translate %s -cir-to-llvmir -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll --check-prefix=LLVM
+
+!s32i = !cir.int<s, 32>
+module {
+    // LLVM: define void @foo()
+    cir.func @foo() cc(c) {
+        cir.return
+    }
+
+    // LLVM: define spir_kernel void @bar()
+    cir.func @bar() cc(spir_kernel) {
+        cir.return
+    }
+
+    // LLVM: define spir_func void @baz()
+    cir.func @baz() cc(spir_function) {
+        cir.return
+    }
+}