llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Narayan (vortex73) <details> <summary>Changes</summary> - [ ] adds checks to called functions containing `Cand->Function` as an argument. - [ ] Assigned `Cand->Function` as a `FunctionDecl*` to enhance readablity. Solves: #<!-- -->98769 and #<!-- -->98942 --- Full diff: https://github.com/llvm/llvm-project/pull/98965.diff 1 Files Affected: - (modified) clang/lib/Sema/SemaOverload.cpp (+23-13) ``````````diff diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 074062ebbb594..b68e54b9caa5b 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -46,6 +46,7 @@ #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Casting.h" #include <algorithm> +#include <cassert> #include <cstddef> #include <cstdlib> #include <optional> @@ -9994,8 +9995,9 @@ Sema::AddArgumentDependentLookupCandidates(DeclarationName Name, CandEnd = CandidateSet.end(); Cand != CandEnd; ++Cand) if (Cand->Function) { - Fns.erase(Cand->Function); - if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate()) + FunctionDecl *CandFunc = Cand->Function; + Fns.erase(CandFunc); + if (FunctionTemplateDecl *FunTmpl = CandFunc->getPrimaryTemplate()) Fns.erase(FunTmpl); } @@ -11349,8 +11351,7 @@ static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, } } - if (TakingCandidateAddress && - !checkAddressOfCandidateIsAvailable(S, Cand->Function)) + if (TakingCandidateAddress && !checkAddressOfCandidateIsAvailable(S, Fn)) return; // Emit the generic diagnostic and, optionally, add the hints to it. @@ -11376,6 +11377,7 @@ static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, /// over a candidate in any candidate set. static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool IsAddressOf = false) { + assert(Cand->Function && "Candidate is required to be a function."); FunctionDecl *Fn = Cand->Function; unsigned MinParams = Fn->getMinRequiredExplicitArguments() + ((IsAddressOf && !Fn->isStatic()) ? 1 : 0); @@ -11466,8 +11468,10 @@ static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D, /// Arity mismatch diagnosis specific to a function overload candidate. static void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand, unsigned NumFormalArgs) { + assert(Cand->Function && "Candidate must be a function"); + FunctionDecl *Fn = Cand->Function; if (!CheckArityMismatch(S, Cand, NumFormalArgs, Cand->TookAddressOfOverload)) - DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs, + DiagnoseArityMismatch(S, Cand->FoundDecl, Fn, NumFormalArgs, Cand->TookAddressOfOverload); } @@ -11767,19 +11771,22 @@ static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, static void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress) { + assert(Cand->Function && "Candidate must be a function"); + FunctionDecl *Fn = Cand->Function; TemplateDeductionResult TDK = Cand->DeductionFailure.getResult(); if (TDK == TemplateDeductionResult::TooFewArguments || TDK == TemplateDeductionResult::TooManyArguments) { if (CheckArityMismatch(S, Cand, NumArgs)) return; } - DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern + DiagnoseBadDeduction(S, Cand->FoundDecl, Fn, // pattern Cand->DeductionFailure, NumArgs, TakingCandidateAddress); } /// CUDA: diagnose an invalid call across targets. static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) { FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true); + assert(Cand->Function && "Candidate must be a Function."); FunctionDecl *Callee = Cand->Function; CUDAFunctionTarget CallerTarget = S.CUDA().IdentifyTarget(Caller), @@ -11837,6 +11844,7 @@ static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) { } static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) { + assert(Cand->Function && "Candidate must be a function"); FunctionDecl *Callee = Cand->Function; EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data); @@ -11846,11 +11854,13 @@ static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) { } static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) { - ExplicitSpecifier ES = ExplicitSpecifier::getFromDecl(Cand->Function); + assert(Cand->Function && "Candidate must be a function"); + Function *CandFunc = Cand->Function; + ExplicitSpecifier ES = ExplicitSpecifier::getFromDecl(CandFunc); assert(ES.isExplicit() && "not an explicit candidate"); unsigned Kind; - switch (Cand->Function->getDeclKind()) { + switch (CandFunc->getDeclKind()) { case Decl::Kind::CXXConstructor: Kind = 0; break; @@ -11858,7 +11868,7 @@ static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) { Kind = 1; break; case Decl::Kind::CXXDeductionGuide: - Kind = Cand->Function->isImplicit() ? 0 : 2; + Kind = CandFunc->isImplicit() ? 0 : 2; break; default: llvm_unreachable("invalid Decl"); @@ -11868,7 +11878,7 @@ static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) { // (particularly an out-of-class definition) will typically lack the // 'explicit' specifier. // FIXME: This is probably a good thing to do for all 'candidate' notes. - FunctionDecl *First = Cand->Function->getFirstDecl(); + FunctionDecl *First = CandFunc->getFirstDecl(); if (FunctionDecl *Pattern = First->getTemplateInstantiationPattern()) First = Pattern->getFirstDecl(); @@ -11937,6 +11947,7 @@ static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, unsigned NumArgs, bool TakingCandidateAddress, LangAS CtorDestAS = LangAS::Default) { + assert(Cand->Function && "Candidate must be a function"); FunctionDecl *Fn = Cand->Function; if (shouldSkipNotingLambdaConversionDecl(Fn)) return; @@ -11951,8 +11962,7 @@ static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, // Skip implicit member functions when trying to resolve // the address of a an overload set for a function pointer. if (Cand->TookAddressOfOverload && - !Cand->Function->hasCXXExplicitFunctionObjectParameter() && - !Cand->Function->isStatic()) + !Fn->hasCXXExplicitFunctionObjectParameter() && !Fn->isStatic()) return; // Note deleted candidates, but only if they're viable. @@ -12050,7 +12060,7 @@ static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, return; case ovl_fail_addr_not_available: { - bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function); + bool Available = checkAddressOfCandidateIsAvailable(S, Fn); (void)Available; assert(!Available); break; `````````` </details> https://github.com/llvm/llvm-project/pull/98965 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
