[clang] [Clang] Add support for GCC bound member functions extension (PR #135649)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Apr 16 03:36:41 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-static-analyzer-1
Author: Yingwei Zheng (dtcxzyw)
<details>
<summary>Changes</summary>
This patch adds support for GCC bound member functions extension: https://gcc.gnu.org/onlinedocs/gcc/Bound-member-functions.html
Closes https://github.com/llvm/llvm-project/issues/82727
---
Patch is 29.68 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/135649.diff
19 Files Affected:
- (modified) clang/docs/ReleaseNotes.rst (+5)
- (modified) clang/include/clang/AST/OperationKinds.def (+4)
- (modified) clang/include/clang/Basic/DiagnosticGroups.td (+16-16)
- (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (+4)
- (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+1)
- (modified) clang/lib/AST/Expr.cpp (+7)
- (modified) clang/lib/AST/ExprConstant.cpp (+2)
- (modified) clang/lib/CIR/CodeGen/CIRGenExpr.cpp (+1)
- (modified) clang/lib/CodeGen/CGExpr.cpp (+1)
- (modified) clang/lib/CodeGen/CGExprAgg.cpp (+2)
- (modified) clang/lib/CodeGen/CGExprComplex.cpp (+1)
- (modified) clang/lib/CodeGen/CGExprConstant.cpp (+1)
- (modified) clang/lib/CodeGen/CGExprScalar.cpp (+32)
- (modified) clang/lib/CodeGen/ItaniumCXXABI.cpp (+20-2)
- (modified) clang/lib/Edit/RewriteObjCFoundationAPI.cpp (+1)
- (modified) clang/lib/Sema/SemaCast.cpp (+40-20)
- (modified) clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp (+2-1)
- (added) clang/test/CodeGenCXX/pmf-conversions.cpp (+105)
- (added) clang/test/SemaCXX/pmf-conversions.cpp (+54)
``````````diff
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 5af4c08f64cd8..768497712ecd6 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -96,6 +96,11 @@ C++ Language Changes
asm((std::string_view("nop")) ::: (std::string_view("memory")));
}
+- Implemented `GCC bound member functions extension <https://gcc.gnu.org/onlinedocs/gcc/Bound-member-functions.html>`_ for Itanium ABI.
+ This extension allows extracting the function pointer from a bound pointer to member function.
+ It is useful to save vtable lookups when the same member function is executed multiple times inside a loop.
+ When using this extension, a warning is emitted unless ``-Wno-pmf-conversions`` is passed.
+
C++2c Feature Support
^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/include/clang/AST/OperationKinds.def b/clang/include/clang/AST/OperationKinds.def
index 790dd572a7c99..489d89a697dc3 100644
--- 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
index d97bbfee2e4d5..8e5a4cba87c95 100644
--- 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
index 3f7499d8656bd..5c882df7fcbdf 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -5144,6 +5144,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
index 0d3c2065cd58c..7dc299827916b 100644
--- 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
index 59c0e47c7c195..e42d626acacb6 100644
--- 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
index d1cc722fb7945..b104a4e9416c0 100644
--- 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
index cffe5c5cd1ec3..1c4a06ad8d61d 100644
--- 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
index abb88477062fc..bf22a62d20c11 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -5417,6 +5417,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
index 87b2a73fb0c03..91fdf8a072111 100644
--- 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
index f556594f4a9ec..008082a493a2a 100644
--- 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
index b21ebeee4bed1..ca3a2cd9af3dd 100644
--- 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
index 8dbbcdaef25d8..fa64df8be8c27 100644
--- a/clang/lib/CodeGen/CGExprScalar.cpp
+++ b/clang/lib/CodeGen/CGExprScalar.cpp
@@ -2628,6 +2628,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
index 70b53be7e77a3..6e4732ea977a9 100644
--- a/clang/lib/CodeGen/ItaniumCXXABI.cpp
+++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp
@@ -926,7 +926,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();
@@ -973,6 +974,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;
@@ -1047,7 +1050,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();
@@ -1057,6 +1061,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
index 627a1d6fb3dd5..51f1de0edae4b 100644
--- 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
index 14e16bc39eb3a..fe1e485cc92a6 100644
--- a/clang/lib/Sema/SemaCast.cpp
+++ b/clang/lib/Sema/SemaCast.cpp
@@ -153,6 +153,11 @@ namespace {
bool isPlaceholder(BuiltinType::Kind K) const {
return PlaceholderKind == K;
}
+ bool isBoundPMFConversion() const {
+ return isPlaceholder(BuiltinType::BoundMember) &&
+ DestType->isFunctionPointerType() &&
+ SrcExpr.get()->isBoundMemberFunction(Self.Context);
+ }
// Language specific cast restrictions for address spaces.
void checkAddressSpaceCast(QualType SrcType, QualType DestType);
@@ -254,13 +259,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,
@@ -1234,9 +1237,10 @@ 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) && !isBoundPMFConversion())
+ SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
+ } else
checkNonOverloadPlaceholders();
if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
return;
@@ -2363,6 +2367,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
@@ -2729,9 +2743,11 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
return;
}
- checkNonOverloadPlaceholders();
- if (SrcExpr.isInvalid())
- return;
+ if (!isBoundPMFConversion()) {
+ checkNonOverloadPlaceholders();
+ if (SrcExpr.isInvalid())
+ return;
+ }
}
// C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void".
@@ -2769,7 +2785,7 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
}
if (ValueKind == VK_PRValue && !DestType->isRecordType() &&
- !isPlaceholder(BuiltinType::Overload)) {
+ !isPlaceholder(BuiltinType::Overload) && !isBoundPMFConversion()) {
SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get());
if (SrcExpr.isInvalid())
return;
@@ -2827,12 +2843,16 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
return;
if (tcr == TC_NotApplicable) {
- // ... or if that is not possible, a static_cast, ignoring const and
- // addr space, ...
- tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange, msg, Kind,
- BasePath, ListInitialization);
- if (SrcExpr.isInvalid())
- return;
+ // FIXME: Bound member function to function pointer conversion is blocked
+ // by an immediat...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/135649
More information about the cfe-commits
mailing list