[CIR][CIRGen] Add CIRGen support for pointer-to-member-functions (#722)

This PR adds the initial CIRGen support for pointer-to-member-functions.
It contains the following new types, attributes, and operations:

  - `!cir.method`, which represents the pointer-to-member-function type.
- `#cir.method`, which represents a literal pointer-to-member-function
value that points to ~~non-virtual~~ member functions.
- ~~`#cir.virtual_method`, which represents a literal
pointer-to-member-function value that points to virtual member
functions.~~
- ~~`cir.get_method_callee`~~ `cir.get_method`, which resolves a
pointer-to-member-function to a function pointer as the callee.

See the new test at `clang/test/CIR/CIRGen/pointer-to-member-func.cpp`
for how these new CIR stuff works to support
pointer-to-member-functions.

Author: Lancern

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -111,6 +111,10 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return getPointerTo(::mlir::cir::VoidType::get(getContext()), langAS);
   }
 
+  mlir::cir::PointerType getVoidPtrTy(mlir::cir::AddressSpaceAttr cirAS) {
+    return getPointerTo(::mlir::cir::VoidType::get(getContext()), cirAS);
+  }
+
   mlir::cir::BoolAttr getCIRBoolAttr(bool state) {
     return mlir::cir::BoolAttr::get(getContext(), getBoolTy(), state);
   }
@@ -590,6 +594,11 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return create<mlir::cir::YieldOp>(loc, value);
   }
 
+  mlir::cir::PtrStrideOp createPtrStride(mlir::Location loc, mlir::Value base,
+                                         mlir::Value stride) {
+    return create<mlir::cir::PtrStrideOp>(loc, base.getType(), base, stride);
+  }
+
   mlir::cir::CallOp
   createCallOp(mlir::Location loc,
                mlir::SymbolRefAttr callee = mlir::SymbolRefAttr(),
@@ -678,6 +687,39 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return createTryCallOp(loc, mlir::SymbolRefAttr(), fn_type.getReturnType(),
                            resOperands);
   }
+
+  struct GetMethodResults {
+    mlir::Value callee;
+    mlir::Value adjustedThis;
+  };
+
+  GetMethodResults createGetMethod(mlir::Location loc, mlir::Value method,
+                                   mlir::Value objectPtr) {
+    // Build the callee function type.
+    auto methodFuncTy =
+        mlir::cast<mlir::cir::MethodType>(method.getType()).getMemberFuncTy();
+    auto methodFuncInputTypes = methodFuncTy.getInputs();
+
+    auto objectPtrTy = mlir::cast<mlir::cir::PointerType>(objectPtr.getType());
+    auto objectPtrAddrSpace =
+        mlir::cast_if_present<mlir::cir::AddressSpaceAttr>(
+            objectPtrTy.getAddrSpace());
+    auto adjustedThisTy = getVoidPtrTy(objectPtrAddrSpace);
+
+    llvm::SmallVector<mlir::Type, 8> calleeFuncInputTypes{adjustedThisTy};
+    calleeFuncInputTypes.insert(calleeFuncInputTypes.end(),
+                                methodFuncInputTypes.begin(),
+                                methodFuncInputTypes.end());
+    auto calleeFuncTy =
+        methodFuncTy.clone(calleeFuncInputTypes, methodFuncTy.getReturnType());
+    // TODO(cir): consider the address space of the callee.
+    assert(!MissingFeatures::addressSpace());
+    auto calleeTy = getPointerTo(calleeFuncTy);
+
+    auto op = create<mlir::cir::GetMethodOp>(loc, calleeTy, adjustedThisTy,
+                                             method, objectPtr);
+    return {op.getCallee(), op.getAdjustedThis()};
+  }
 };
 
 } // namespace cir

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

@@ -441,6 +441,54 @@ def DataMemberAttr : CIR_Attr<"DataMember", "data_member",
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// MethodAttr
+//===----------------------------------------------------------------------===//
+
+def MethodAttr : CIR_Attr<"Method", "method", [TypedAttrInterface]> {
+  let summary = "Holds a constant pointer-to-member-function value";
+  let description = [{
+    A method attribute is a literal attribute that represents a constant
+    pointer-to-member-function value.
+
+    If the member function is a non-virtual function, the `symbol` parameter
+    gives the global symbol for the non-virtual member function.
+
+    If the member function is a virtual function, the `vtable_offset` parameter
+    gives the offset of the vtable entry corresponding to the virtual member
+    function.
+
+    `symbol` and `vtable_offset` cannot be present at the same time. If both of
+    `symbol` and `vtable_offset` are not present, the attribute represents a
+    null pointer constant.
+  }];
+
+  let parameters = (ins AttributeSelfTypeParameter<
+                            "", "mlir::cir::MethodType">:$type,
+                        OptionalParameter<
+                            "std::optional<FlatSymbolRefAttr>">:$symbol,
+                        OptionalParameter<
+                            "std::optional<uint64_t>">:$vtable_offset);
+
+  let builders = [
+    AttrBuilderWithInferredContext<(ins "mlir::cir::MethodType":$type), [{
+      return $_get(type.getContext(), type, std::nullopt, std::nullopt);
+    }]>,
+    AttrBuilderWithInferredContext<(ins "mlir::cir::MethodType":$type,
+                                        "FlatSymbolRefAttr":$symbol), [{
+      return $_get(type.getContext(), type, symbol, std::nullopt);
+    }]>,
+    AttrBuilderWithInferredContext<(ins "mlir::cir::MethodType":$type,
+                                        "uint64_t":$vtable_offset), [{
+      return $_get(type.getContext(), type, std::nullopt, vtable_offset);
+    }]>,
+  ];
+
+  let hasCustomAssemblyFormat = 1;
+
+  let genVerifyDecl = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // SignedOverflowBehaviorAttr
 //===----------------------------------------------------------------------===//

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

@@ -2589,6 +2589,60 @@ def GetRuntimeMemberOp : CIR_Op<"get_runtime_member"> {
   let hasVerifier = 1;
 }
 
+//===----------------------------------------------------------------------===//
+// GetMethodOp
+//===----------------------------------------------------------------------===//
+
+def GetMethodOp : CIR_Op<"get_method"> {
+  let summary = "Resolve a method to a function pointer as callee";
+  let description = [{
+    The `cir.get_method` operation takes a method and an object as input, and
+    yields a function pointer that points to the actual function corresponding
+    to the input method. The operation also applies any necessary adjustments to
+    the input object pointer for calling the method and yields the adjusted
+    pointer.
+
+    This operation is generated when calling a method through a pointer-to-
+    member-function in C++:
+
+    ```cpp
+    // Foo *object;
+    // int arg;
+    // void (Foo::*method)(int);
+
+    (object->*method)(arg);
+    ```
+
+    The code above will generate CIR similar as:
+
+    ```mlir
+    // %object = ...
+    // %arg = ...
+    // %method = ...
+    %callee, %this = cir.get_method %method, %object
+    cir.call %callee(%this, %arg)
+    ```
+
+    The method type must match the callee type. That is:
+    - The return type of the method must match the return type of the callee.
+    - The first parameter of the callee must have type `!cir.ptr<!cir.void>`.
+    - Types of other parameters of the callee must match the parameters of the
+      method.
+  }];
+
+  let arguments = (ins CIR_MethodType:$method, StructPtr:$object);
+  let results = (outs FuncPtr:$callee, VoidPtr:$adjusted_this);
+
+  let assemblyFormat = [{
+    $method `,` $object
+    `:` `(` qualified(type($method)) `,` qualified(type($object)) `)`
+    `->` `(` qualified(type($callee)) `,` qualified(type($adjusted_this)) `)`
+    attr-dict
+  }];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // VecInsertOp
 //===----------------------------------------------------------------------===//

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

@@ -408,6 +408,26 @@ def CIR_FuncType : CIR_Type<"Func", "func"> {
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// MethodType
+//===----------------------------------------------------------------------===//
+
+def CIR_MethodType : CIR_Type<"Method", "method",
+    [DeclareTypeInterfaceMethods<DataLayoutTypeInterface>]> {
+  let summary = "CIR type that represents C++ pointer-to-member-function type";
+  let description = [{
+    `cir.method` models the pointer-to-member-function type in C++. The layout
+    of this type is ABI-dependent.
+  }];
+
+  let parameters = (ins "mlir::cir::FuncType":$memberFuncTy,
+                        "mlir::cir::StructType":$clsTy);
+
+  let assemblyFormat = [{
+    `<` qualified($memberFuncTy) `in` $clsTy `>`
+  }];
+}
+
 //===----------------------------------------------------------------------===//
 // Exception info type
 //
@@ -517,6 +537,15 @@ def ArrayPtr : Type<
     ]>, "!cir.ptr<!cir.eh_info>"> {
 }
 
+// Pointer to functions
+def FuncPtr : Type<
+    And<[
+      CPred<"::mlir::isa<::mlir::cir::PointerType>($_self)">,
+      CPred<"::mlir::isa<::mlir::cir::FuncType>("
+            "::mlir::cast<::mlir::cir::PointerType>($_self).getPointee())">,
+    ]>, "!cir.ptr<!cir.func>"> {
+}
+
 //===----------------------------------------------------------------------===//
 // StructType (defined in cpp files)
 //===----------------------------------------------------------------------===//
@@ -529,9 +558,10 @@ def CIR_StructType : Type<CPred<"::mlir::isa<::mlir::cir::StructType>($_self)">,
 //===----------------------------------------------------------------------===//
 
 def CIR_AnyType : AnyTypeOf<[
-  CIR_IntType, CIR_PointerType, CIR_DataMemberType, CIR_BoolType, CIR_ArrayType,
-  CIR_VectorType, CIR_FuncType, CIR_VoidType, CIR_StructType, CIR_ExceptionType,
-  CIR_AnyFloat, CIR_FP16, CIR_BFloat16, CIR_ComplexType
+  CIR_IntType, CIR_PointerType, CIR_DataMemberType, CIR_MethodType,
+  CIR_BoolType, CIR_ArrayType, CIR_VectorType, CIR_FuncType, CIR_VoidType,
+  CIR_StructType, CIR_ExceptionType, CIR_AnyFloat, CIR_FP16, CIR_BFloat16,
+  CIR_ComplexType
 ]>;
 
 #endif // MLIR_CIR_DIALECT_CIR_TYPES

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -241,6 +241,16 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return mlir::cir::DataMemberAttr::get(getContext(), ty, std::nullopt);
   }
 
+  mlir::cir::MethodAttr getMethodAttr(mlir::cir::MethodType ty,
+                                      mlir::cir::FuncOp methodFuncOp) {
+    auto methodFuncSymbolRef = mlir::FlatSymbolRefAttr::get(methodFuncOp);
+    return mlir::cir::MethodAttr::get(ty, methodFuncSymbolRef);
+  }
+
+  mlir::cir::MethodAttr getNullMethodAttr(mlir::cir::MethodType ty) {
+    return mlir::cir::MethodAttr::get(ty);
+  }
+
   // TODO(cir): Once we have CIR float types, replace this by something like a
   // NullableValueInterface to allow for type-independent queries.
   bool isNullValue(mlir::Attribute attr) const {
@@ -520,6 +530,11 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return create<mlir::cir::ConstantOp>(loc, ty, getNullDataMemberAttr(ty));
   }
 
+  mlir::cir::ConstantOp getNullMethodPtr(mlir::cir::MethodType ty,
+                                         mlir::Location loc) {
+    return create<mlir::cir::ConstantOp>(loc, ty, getNullMethodAttr(ty));
+  }
+
   mlir::cir::ConstantOp getZero(mlir::Location loc, mlir::Type ty) {
     // TODO: dispatch creation for primitive types.
     assert((mlir::isa<mlir::cir::StructType>(ty) ||

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -310,6 +310,10 @@ class CIRGenCXXABI {
                                        QualType DestRecordTy,
                                        mlir::cir::PointerType DestCIRTy,
                                        bool isRefCast, Address Src) = 0;
+
+  virtual mlir::cir::MethodAttr
+  buildVirtualMethodAttr(mlir::cir::MethodType MethodTy,
+                         const CXXMethodDecl *MD) = 0;
 };
 
 /// Creates and Itanium-family ABI

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -731,7 +731,7 @@ RValue CIRGenFunction::buildCall(const CIRGenFunctionInfo &CallInfo,
       [[maybe_unused]] auto resultTypes = CalleePtr->getResultTypes();
       [[maybe_unused]] auto FuncPtrTy =
           mlir::dyn_cast<mlir::cir::PointerType>(resultTypes.front());
-      assert((resultTypes.size() == 1) && FuncPtrTy &&
+      assert(FuncPtrTy &&
              mlir::isa<mlir::cir::FuncType>(FuncPtrTy.getPointee()) &&
              "expected pointer to function");
 

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2834,7 +2834,7 @@ RValue CIRGenFunction::buildCXXMemberCallExpr(const CXXMemberCallExpr *CE,
   const Expr *callee = CE->getCallee()->IgnoreParens();
 
   if (isa<BinaryOperator>(callee))
-    llvm_unreachable("NYI");
+    return buildCXXMemberPointerCallExpr(CE, ReturnValue);
 
   const auto *ME = cast<MemberExpr>(callee);
   const auto *MD = cast<CXXMethodDecl>(ME->getMemberDecl());

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -105,6 +105,53 @@ static CXXRecordDecl *getCXXRecord(const Expr *E) {
   return cast<CXXRecordDecl>(Ty->getDecl());
 }
 
+RValue
+CIRGenFunction::buildCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
+                                              ReturnValueSlot ReturnValue) {
+  const BinaryOperator *BO =
+      cast<BinaryOperator>(E->getCallee()->IgnoreParens());
+  const Expr *BaseExpr = BO->getLHS();
+  const Expr *MemFnExpr = BO->getRHS();
+
+  const auto *MPT = MemFnExpr->getType()->castAs<MemberPointerType>();
+  const auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
+  const auto *RD =
+      cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());
+
+  // Emit the 'this' pointer.
+  Address This = Address::invalid();
+  if (BO->getOpcode() == BO_PtrMemI)
+    This = buildPointerWithAlignment(BaseExpr, nullptr, KnownNonNull);
+  else
+    This = buildLValue(BaseExpr).getAddress();
+
+  buildTypeCheck(TCK_MemberCall, E->getExprLoc(), This.emitRawPointer(),
+                 QualType(MPT->getClass(), 0));
+
+  // Get the member function pointer.
+  mlir::Value MemFnPtr = buildScalarExpr(MemFnExpr);
+
+  // Resolve the member function pointer to the actual callee and adjust the
+  // "this" pointer for call.
+  auto Loc = getLoc(E->getExprLoc());
+  auto [CalleePtr, AdjustedThis] =
+      builder.createGetMethod(Loc, MemFnPtr, This.getPointer());
+
+  // Prepare the call arguments.
+  CallArgList ArgsList;
+  ArgsList.add(RValue::get(AdjustedThis), getContext().VoidPtrTy);
+  buildCallArgs(ArgsList, FPT, E->arguments());
+
+  RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, 1);
+
+  // Build the call.
+  CIRGenCallee Callee(FPT, CalleePtr.getDefiningOp());
+  return buildCall(CGM.getTypes().arrangeCXXMethodCall(ArgsList, FPT, required,
+                                                       /*PrefixSize=*/0),
+                   Callee, ReturnValue, ArgsList, nullptr, E == MustTailCall,
+                   Loc);
+}
+
 RValue CIRGenFunction::buildCXXMemberOrOperatorMemberCallExpr(
     const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
     bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "Address.h"
+#include "CIRGenCXXABI.h"
 #include "CIRGenCstEmitter.h"
 #include "CIRGenFunction.h"
 #include "CIRGenModule.h"
@@ -1890,9 +1891,16 @@ mlir::Value CIRGenModule::buildMemberPointerConstant(const UnaryOperator *E) {
   const auto *decl = cast<DeclRefExpr>(E->getSubExpr())->getDecl();
 
   // A member function pointer.
-  // Member function pointer is not supported yet.
-  if (const auto *methodDecl = dyn_cast<CXXMethodDecl>(decl))
-    assert(0 && "not implemented");
+  if (const auto *methodDecl = dyn_cast<CXXMethodDecl>(decl)) {
+    auto ty = mlir::cast<mlir::cir::MethodType>(getCIRType(E->getType()));
+    if (methodDecl->isVirtual())
+      return builder.create<mlir::cir::ConstantOp>(
+          loc, ty, getCXXABI().buildVirtualMethodAttr(ty, methodDecl));
+
+    auto methodFuncOp = GetAddrOfFunction(methodDecl);
+    return builder.create<mlir::cir::ConstantOp>(
+        loc, ty, builder.getMethodAttr(ty, methodFuncOp));
+  }
 
   auto ty = mlir::cast<mlir::cir::DataMemberType>(getCIRType(E->getType()));
 

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1680,7 +1680,10 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     assert(!MissingFeatures::cxxABI());
 
     const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>();
-    assert(!MPT->isMemberFunctionPointerType() && "NYI");
+    if (MPT->isMemberFunctionPointerType()) {
+      auto Ty = mlir::cast<mlir::cir::MethodType>(CGF.getCIRType(DestTy));
+      return Builder.getNullMethodPtr(Ty, CGF.getLoc(E->getExprLoc()));
+    }
 
     auto Ty = mlir::cast<mlir::cir::DataMemberType>(CGF.getCIRType(DestTy));
     return Builder.getNullDataMemberPtr(Ty, CGF.getLoc(E->getExprLoc()));

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -622,6 +622,8 @@ class CIRGenFunction : public CIRGenTypeCache {
 
   RValue buildCXXMemberCallExpr(const clang::CXXMemberCallExpr *E,
                                 ReturnValueSlot ReturnValue);
+  RValue buildCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
+                                       ReturnValueSlot ReturnValue);
   RValue buildCXXMemberOrOperatorMemberCallExpr(
       const clang::CallExpr *CE, const clang::CXXMethodDecl *MD,
       ReturnValueSlot ReturnValue, bool HasQualifier,