[Clang] Add support for GCC bound member functions extension

dtcxzyw · dtcxzyw · commit 445c08bcb007 · 2025-04-15T22:58:44.000+08:00
diff --git a/clang/include/clang/AST/OperationKinds.def b/clang/include/clang/AST/OperationKinds.def
@@ -152,6 +152,10 @@ CAST_OPERATION(MemberPointerToBoolean)
 /// many ABIs do not guarantee this on all possible intermediate types).
 CAST_OPERATION(ReinterpretMemberPointer)
 
+/// CK_BoundPointerToMemberFunctionToFunctionPointer - Convert a bound
+/// member function pointer to a function pointer.  This is a GNU extension.
+CAST_OPERATION(BoundMemberFunctionToFunctionPointer)
+
 /// CK_UserDefinedConversion - Conversion using a user defined type
 /// conversion function.
 ///    struct A { operator int(); }; int i = int(A());
diff --git a/clang/include/clang/Basic/DiagnosticGroups.td b/clang/include/clang/Basic/DiagnosticGroups.td
@@ -795,6 +795,7 @@ def DuplicateDeclSpecifier : DiagGroup<"duplicate-decl-specifier">;
 def CompareDistinctPointerType : DiagGroup<"compare-distinct-pointer-types">;
 def GNUUnionCast : DiagGroup<"gnu-union-cast">;
 def GNUVariableSizedTypeNotAtEnd : DiagGroup<"gnu-variable-sized-type-not-at-end">;
+def GNUPMFCast : DiagGroup<"pmf-conversions">;
 def Varargs : DiagGroup<"varargs">;
 def XorUsedAsPow : DiagGroup<"xor-used-as-pow">;
 
@@ -1294,22 +1295,21 @@ def C2y : DiagGroup<"c2y-extensions">;
 def GNUBinaryLiteral : DiagGroup<"gnu-binary-literal">;
 
 // A warning group for warnings about GCC extensions.
-def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
-                            GNUAutoType, GNUBinaryLiteral, GNUCaseRange,
-                            GNUComplexInteger, GNUCompoundLiteralInitializer,
-                            GNUConditionalOmittedOperand, GNUDesignator,
-                            GNUEmptyStruct,
-                            VLAExtension, GNUFlexibleArrayInitializer,
-                            GNUFlexibleArrayUnionMember, GNUFoldingConstant,
-                            GNUImaginaryConstant, GNUIncludeNext,
-                            GNULabelsAsValue, GNULineMarker, GNUNullPointerArithmetic,
-                            GNUOffsetofExtensions, GNUPointerArith,
-                            RedeclaredClassMember, GNURedeclaredEnum,
-                            GNUStatementExpression, GNUStaticFloatInit,
-                            GNUStringLiteralOperatorTemplate, GNUUnionCast,
-                            GNUVariableSizedTypeNotAtEnd, ZeroLengthArray,
-                            GNUZeroLineDirective,
-                            GNUZeroVariadicMacroArguments]>;
+def GNU
+    : DiagGroup<
+          "gnu", [GNUAlignofExpression, GNUAnonymousStruct, GNUAutoType,
+                  GNUBinaryLiteral, GNUCaseRange, GNUComplexInteger,
+                  GNUCompoundLiteralInitializer, GNUConditionalOmittedOperand,
+                  GNUDesignator, GNUEmptyStruct, VLAExtension,
+                  GNUFlexibleArrayInitializer, GNUFlexibleArrayUnionMember,
+                  GNUFoldingConstant, GNUImaginaryConstant, GNUIncludeNext,
+                  GNULabelsAsValue, GNULineMarker, GNUNullPointerArithmetic,
+                  GNUOffsetofExtensions, GNUPointerArith, RedeclaredClassMember,
+                  GNURedeclaredEnum, GNUStatementExpression, GNUStaticFloatInit,
+                  GNUStringLiteralOperatorTemplate, GNUUnionCast,
+                  GNUVariableSizedTypeNotAtEnd, ZeroLengthArray,
+                  GNUZeroLineDirective, GNUZeroVariadicMacroArguments,
+                  GNUPMFCast]>;
 // A warning group for warnings about code that clang accepts but gcc doesn't.
 def GccCompat : DiagGroup<"gcc-compat">;
 
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -5120,6 +5120,10 @@ def err_ovl_unresolvable : Error<
 def err_bound_member_function : Error<
   "reference to non-static member function must be called"
   "%select{|; did you mean to call it with no arguments?}0">;
+def ext_bound_member_function_conversion
+    : ExtWarn<"converting the bound member function %1 to a function pointer "
+              "%2 is a GNU extension">,
+      InGroup<GNUPMFCast>;
 def note_possible_target_of_call : Note<"possible target for call">;
 def err_no_viable_destructor : Error<
   "no viable destructor found for class %0">;
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -109,6 +109,7 @@ def CK_ArrayToPointerDecay : I32EnumAttrCase<"array_to_ptrdecay", 11>;
 // CK_DerivedToBaseMemberPointer
 def CK_MemberPointerToBoolean : I32EnumAttrCase<"member_ptr_to_bool", 17>;
 // CK_ReinterpretMemberPointer
+// CK_BoundMemberFunctionToFunctionPointer
 // CK_UserDefinedConversion
 // CK_ConstructorConversion
 def CK_IntegralToPointer : I32EnumAttrCase<"int_to_ptr", 21>;
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
@@ -1864,6 +1864,13 @@ bool CastExpr::CastConsistency() const {
     assert(getSubExpr()->getType()->isMemberPointerType());
     goto CheckNoBasePath;
 
+  case CK_BoundMemberFunctionToFunctionPointer:
+    assert(getType()->isFunctionPointerType());
+    assert(getSubExpr()->getType()->isMemberPointerType() ||
+           getSubExpr()->getType()->isSpecificPlaceholderType(
+               BuiltinType::BoundMember));
+    goto CheckNoBasePath;
+
   case CK_BitCast:
     // Arbitrary casts to C pointer types count as bitcasts.
     // Otherwise, we should only have block and ObjC pointer casts
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
@@ -15103,6 +15103,7 @@ bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_BaseToDerivedMemberPointer:
   case CK_DerivedToBaseMemberPointer:
   case CK_ReinterpretMemberPointer:
+  case CK_BoundMemberFunctionToFunctionPointer:
   case CK_ConstructorConversion:
   case CK_IntegralToPointer:
   case CK_ToVoid:
@@ -15960,6 +15961,7 @@ bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
   case CK_DerivedToBaseMemberPointer:
   case CK_MemberPointerToBoolean:
   case CK_ReinterpretMemberPointer:
+  case CK_BoundMemberFunctionToFunctionPointer:
   case CK_ConstructorConversion:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -83,6 +83,7 @@ Address CIRGenFunction::emitPointerWithAlignment(const Expr *expr,
     case CK_NullToMemberPointer:
     case CK_NullToPointer:
     case CK_ReinterpretMemberPointer:
+    case CK_BoundMemberFunctionToFunctionPointer:
       // Common pointer conversions, nothing to do here.
       // TODO: Is there any reason to treat base-to-derived conversions
       // specially?
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
@@ -5387,6 +5387,7 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
   case CK_BaseToDerivedMemberPointer:
   case CK_MemberPointerToBoolean:
   case CK_ReinterpretMemberPointer:
+  case CK_BoundMemberFunctionToFunctionPointer:
   case CK_AnyPointerToBlockPointerCast:
   case CK_ARCProduceObject:
   case CK_ARCConsumeObject:
diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp
@@ -1043,6 +1043,7 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) {
   case CK_DerivedToBaseMemberPointer:
   case CK_MemberPointerToBoolean:
   case CK_ReinterpretMemberPointer:
+  case CK_BoundMemberFunctionToFunctionPointer:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
   case CK_PointerToBoolean:
@@ -1600,6 +1601,7 @@ static bool castPreservesZero(const CastExpr *CE) {
   case CK_MemberPointerToBoolean:
   case CK_NullToMemberPointer:
   case CK_ReinterpretMemberPointer:
+  case CK_BoundMemberFunctionToFunctionPointer:
     // FIXME: ABI-dependent.
     return false;
 
diff --git a/clang/lib/CodeGen/CGExprComplex.cpp b/clang/lib/CodeGen/CGExprComplex.cpp
@@ -575,6 +575,7 @@ ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
   case CK_DerivedToBaseMemberPointer:
   case CK_MemberPointerToBoolean:
   case CK_ReinterpretMemberPointer:
+  case CK_BoundMemberFunctionToFunctionPointer:
   case CK_ConstructorConversion:
   case CK_IntegralToPointer:
   case CK_PointerToIntegral:
diff --git a/clang/lib/CodeGen/CGExprConstant.cpp b/clang/lib/CodeGen/CGExprConstant.cpp
@@ -1272,6 +1272,7 @@ class ConstExprEmitter
       llvm_unreachable("builtin functions are handled elsewhere");
 
     case CK_ReinterpretMemberPointer:
+    case CK_BoundMemberFunctionToFunctionPointer:
     case CK_DerivedToBaseMemberPointer:
     case CK_BaseToDerivedMemberPointer: {
       auto C = Emitter.tryEmitPrivate(subExpr, subExpr->getType());
diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp
@@ -2581,6 +2581,38 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
   }
 
+  case CK_BoundMemberFunctionToFunctionPointer: {
+    // Special handling bound member functions
+    if (E->isBoundMemberFunction(CGF.getContext())) {
+      auto *BO = cast<BinaryOperator>(E->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 = MPT->getMostRecentCXXRecordDecl();
+
+      // Emit the 'this' pointer.
+      Address This = Address::invalid();
+      if (BO->getOpcode() == BO_PtrMemI)
+        This = CGF.EmitPointerWithAlignment(BaseExpr, nullptr, nullptr,
+                                            KnownNonNull);
+      else
+        This = CGF.EmitLValue(BaseExpr, KnownNonNull).getAddress();
+
+      // Get the member function pointer.
+      llvm::Value *MemFnPtr = CGF.EmitScalarExpr(MemFnExpr);
+
+      // Ask the ABI to load the callee.  Note that This is modified.
+      llvm::Value *ThisPtrForCall = nullptr;
+      CGCallee Callee = CGF.CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(
+          CGF, BO, This, ThisPtrForCall, MemFnPtr, MPT);
+      return Callee.getFunctionPointer();
+    }
+
+    // fallback to the case without the base object address
+  }
+    [[fallthrough]];
   case CK_ReinterpretMemberPointer:
   case CK_BaseToDerivedMemberPointer:
   case CK_DerivedToBaseMemberPointer: {
diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp b/clang/lib/CodeGen/ItaniumCXXABI.cpp
@@ -930,7 +930,8 @@ ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
 
   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
          E->getCastKind() == CK_BaseToDerivedMemberPointer ||
-         E->getCastKind() == CK_ReinterpretMemberPointer);
+         E->getCastKind() == CK_ReinterpretMemberPointer ||
+         E->getCastKind() == CK_BoundMemberFunctionToFunctionPointer);
 
   CGBuilderTy &Builder = CGF.Builder;
   QualType DstType = E->getType();
@@ -977,6 +978,8 @@ ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
 
   // Under Itanium, reinterprets don't require any additional processing.
   if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
+  if (E->getCastKind() == CK_BoundMemberFunctionToFunctionPointer)
+    return Builder.CreateExtractValue(src, 0, "src.ptr");
 
   llvm::Constant *adj = getMemberPointerAdjustment(E);
   if (!adj) return src;
@@ -1051,7 +1054,8 @@ ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
                                            llvm::Constant *src) {
   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
          E->getCastKind() == CK_BaseToDerivedMemberPointer ||
-         E->getCastKind() == CK_ReinterpretMemberPointer);
+         E->getCastKind() == CK_ReinterpretMemberPointer ||
+         E->getCastKind() == CK_BoundMemberFunctionToFunctionPointer);
 
   QualType DstType = E->getType();
 
@@ -1061,6 +1065,20 @@ ItaniumCXXABI::EmitMemberPointerConversion(const CastExpr *E,
 
   // Under Itanium, reinterprets don't require any additional processing.
   if (E->getCastKind() == CK_ReinterpretMemberPointer) return src;
+  if (E->getCastKind() == CK_BoundMemberFunctionToFunctionPointer) {
+    llvm::Type *PtrTy = llvm::PointerType::getUnqual(CGM.getLLVMContext());
+    llvm::Constant *FuncPtr = llvm::ConstantExpr::getIntToPtr(
+        ConstantFoldExtractValueInstruction(src, 0), PtrTy);
+
+    const auto &NewAuthInfo = CGM.getFunctionPointerAuthInfo(DstType);
+    const auto &CurAuthInfo =
+        CGM.getMemberFunctionPointerAuthInfo(E->getSubExpr()->getType());
+
+    if (!NewAuthInfo && !CurAuthInfo)
+      return FuncPtr;
+
+    return pointerAuthResignConstant(FuncPtr, CurAuthInfo, NewAuthInfo, CGM);
+  }
 
   // If the adjustment is trivial, we don't need to do anything.
   llvm::Constant *adj = getMemberPointerAdjustment(E);
diff --git a/clang/lib/Edit/RewriteObjCFoundationAPI.cpp b/clang/lib/Edit/RewriteObjCFoundationAPI.cpp
@@ -1054,6 +1054,7 @@ static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg,
     case CK_DerivedToBaseMemberPointer:
     case CK_MemberPointerToBoolean:
     case CK_ReinterpretMemberPointer:
+    case CK_BoundMemberFunctionToFunctionPointer:
     case CK_ConstructorConversion:
     case CK_IntegralToPointer:
     case CK_PointerToIntegral:
diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp
@@ -243,13 +243,11 @@ static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType,
                                        QualType OrigDestType, unsigned &msg,
                                        CastKind &Kind,
                                        CXXCastPath &BasePath);
-static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr,
-                                               QualType SrcType,
-                                               QualType DestType,bool CStyle,
-                                               SourceRange OpRange,
-                                               unsigned &msg,
-                                               CastKind &Kind,
-                                               CXXCastPath &BasePath);
+static TryCastResult
+TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType,
+                             QualType DestType, bool CStyle,
+                             SourceRange OpRange, unsigned &msg, CastKind &Kind,
+                             CXXCastPath &BasePath);
 
 static TryCastResult
 TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType,
@@ -1198,9 +1196,12 @@ static unsigned int checkCastFunctionType(Sema &Self, const ExprResult &SrcExpr,
 /// like this:
 /// char *bytes = reinterpret_cast\<char*\>(int_ptr);
 void CastOperation::CheckReinterpretCast() {
-  if (ValueKind == VK_PRValue && !isPlaceholder(BuiltinType::Overload))
-    SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
-  else
+  if (ValueKind == VK_PRValue) {
+    if (!isPlaceholder(BuiltinType::Overload) &&
+        !(isPlaceholder(BuiltinType::BoundMember) &&
+          DestType->isFunctionPointerType()))
+      SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
+  } else
     checkNonOverloadPlaceholders();
   if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
     return;
@@ -2327,6 +2328,16 @@ static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr,
     return TC_Success;
   }
 
+  // GNU extension: check if we can convert a pmf to a function pointer
+  if (DestType->isFunctionPointerType() &&
+      (SrcType->isMemberFunctionPointerType() ||
+       SrcExpr.get()->isBoundMemberFunction(Self.Context)) &&
+      Self.Context.getTargetInfo().getCXXABI().isItaniumFamily()) {
+    Kind = CK_BoundMemberFunctionToFunctionPointer;
+    msg = diag::ext_bound_member_function_conversion;
+    return TC_Extension;
+  }
+
   // See below for the enumeral issue.
   if (SrcType->isNullPtrType() && DestType->isIntegralType(Self.Context)) {
     // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp
@@ -524,7 +524,8 @@ void ExprEngine::VisitCast(const CastExpr *CastE, const Expr *Ex,
       case CK_VectorSplat:
       case CK_HLSLElementwiseCast:
       case CK_HLSLAggregateSplatCast:
-      case CK_HLSLVectorTruncation: {
+      case CK_HLSLVectorTruncation:
+      case CK_BoundMemberFunctionToFunctionPointer: {
         QualType resultType = CastE->getType();
         if (CastE->isGLValue())
           resultType = getContext().getPointerType(resultType);
diff --git a/clang/test/CodeGenCXX/pmf-conversions.cpp b/clang/test/CodeGenCXX/pmf-conversions.cpp
diff --git a/clang/test/SemaCXX/pmf-conversions.cpp b/clang/test/SemaCXX/pmf-conversions.cpp
