EIC code displayed by LXR master/​include/​clang/​Analysis/​RetainSummaryManager.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:36:26

 //=== RetainSummaryManager.h - Summaries for reference counting ---*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines summaries implementation for retain counting, which
 //  implements a reference count checker for Core Foundation and Cocoa
 //  on (Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_RETAINSUMMARYMANAGER_H
 #define LLVM_CLANG_ANALYSIS_RETAINSUMMARYMANAGER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/Analysis/AnyCall.h"
 #include "clang/Analysis/SelectorExtras.h"
 #include "llvm/ADT/STLExtras.h"
 #include <optional>
 
 using namespace clang;
 
 namespace clang {
 namespace ento {
 
 /// Determines the object kind of a tracked object.
 enum class ObjKind {
   /// Indicates that the tracked object is a CF object.
   CF,
 
   /// Indicates that the tracked object is an Objective-C object.
   ObjC,
 
   /// Indicates that the tracked object could be a CF or Objective-C object.
   AnyObj,
 
   /// Indicates that the tracked object is a generalized object.
   Generalized,
 
   /// Indicates that the tracking object is a descendant of a
   /// referenced-counted OSObject, used in the Darwin kernel.
   OS
 };
 
 enum ArgEffectKind {
   /// There is no effect.
   DoNothing,
 
   /// The argument is treated as if an -autorelease message had been sent to
   /// the referenced object.
   Autorelease,
 
   /// The argument is treated as if the referenced object was deallocated.
   Dealloc,
 
   /// The argument has its reference count decreased by 1.
   DecRef,
 
   /// The argument has its reference count decreased by 1 to model
   /// a transferred bridge cast under ARC.
   DecRefBridgedTransferred,
 
   /// The argument has its reference count increased by 1.
   IncRef,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +0 value.
   UnretainedOutParameter,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value.
   RetainedOutParameter,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value iff the return code is zero.
   RetainedOutParameterOnZero,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value iff the return code is non-zero.
   RetainedOutParameterOnNonZero,
 
   /// The argument is treated as potentially escaping, meaning that
   /// even when its reference count hits 0 it should be treated as still
   /// possibly being alive as someone else *may* be holding onto the object.
   MayEscape,
 
   /// All typestate tracking of the object ceases.  This is usually employed
   /// when the effect of the call is completely unknown.
   StopTracking,
 
   /// All typestate tracking of the object ceases.  Unlike StopTracking,
   /// this is also enforced when the method body is inlined.
   ///
   /// In some cases, we obtain a better summary for this checker
   /// by looking at the call site than by inlining the function.
   /// Signifies that we should stop tracking the symbol even if
   /// the function is inlined.
   StopTrackingHard,
 
   /// Performs the combined functionality of DecRef and StopTrackingHard.
   ///
   /// The models the effect that the called function decrements the reference
   /// count of the argument and all typestate tracking on that argument
   /// should cease.
   DecRefAndStopTrackingHard,
 };
 
 /// An ArgEffect summarizes the retain count behavior on an argument or receiver
 /// to a function or method.
 class ArgEffect {
   ArgEffectKind K;
   ObjKind O;
 public:
   explicit ArgEffect(ArgEffectKind K = DoNothing, ObjKind O = ObjKind::AnyObj)
       : K(K), O(O) {}
 
   ArgEffectKind getKind() const { return K; }
   ObjKind getObjKind() const { return O; }
 
   ArgEffect withKind(ArgEffectKind NewK) {
     return ArgEffect(NewK, O);
   }
 
   bool operator==(const ArgEffect &Other) const {
     return K == Other.K && O == Other.O;
   }
 };
 
 /// RetEffect summarizes a call's retain/release behavior with respect
 /// to its return value.
 class RetEffect {
 public:
   enum Kind {
     /// Indicates that no retain count information is tracked for
     /// the return value.
     NoRet,
 
     /// Indicates that the returned value is an owned (+1) symbol.
     OwnedSymbol,
 
     /// Indicates that the returned value is an object with retain count
     /// semantics but that it is not owned (+0).  This is the default
     /// for getters, etc.
     NotOwnedSymbol,
 
     /// Indicates that the return value is an owned object when the
     /// receiver is also a tracked object.
     OwnedWhenTrackedReceiver,
 
     // Treat this function as returning a non-tracked symbol even if
     // the function has been inlined. This is used where the call
     // site summary is more precise than the summary indirectly produced
     // by inlining the function
     NoRetHard
   };
 
 private:
   Kind K;
   ObjKind O;
 
   RetEffect(Kind k, ObjKind o = ObjKind::AnyObj) : K(k), O(o) {}
 
 public:
   Kind getKind() const { return K; }
 
   ObjKind getObjKind() const { return O; }
 
   bool isOwned() const {
     return K == OwnedSymbol || K == OwnedWhenTrackedReceiver;
   }
 
   bool notOwned() const {
     return K == NotOwnedSymbol;
   }
 
   bool operator==(const RetEffect &Other) const {
     return K == Other.K && O == Other.O;
   }
 
   static RetEffect MakeOwnedWhenTrackedReceiver() {
     return RetEffect(OwnedWhenTrackedReceiver, ObjKind::ObjC);
   }
 
   static RetEffect MakeOwned(ObjKind o) {
     return RetEffect(OwnedSymbol, o);
   }
   static RetEffect MakeNotOwned(ObjKind o) {
     return RetEffect(NotOwnedSymbol, o);
   }
   static RetEffect MakeNoRet() {
     return RetEffect(NoRet);
   }
   static RetEffect MakeNoRetHard() {
     return RetEffect(NoRetHard);
   }
 };
 
 /// A key identifying a summary.
 class ObjCSummaryKey {
   IdentifierInfo* II;
   Selector S;
 public:
   ObjCSummaryKey(IdentifierInfo* ii, Selector s)
     : II(ii), S(s) {}
 
   ObjCSummaryKey(const ObjCInterfaceDecl *d, Selector s)
     : II(d ? d->getIdentifier() : nullptr), S(s) {}
 
   ObjCSummaryKey(Selector s)
     : II(nullptr), S(s) {}
 
   IdentifierInfo *getIdentifier() const { return II; }
   Selector getSelector() const { return S; }
 };
 
 } // end namespace ento
 } // end namespace clang
 
 using namespace ento;
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // Adapters for FoldingSet.
 //===----------------------------------------------------------------------===//
 template <> struct FoldingSetTrait<ArgEffect> {
 static inline void Profile(const ArgEffect X, FoldingSetNodeID &ID) {
   ID.AddInteger((unsigned) X.getKind());
   ID.AddInteger((unsigned) X.getObjKind());
 }
 };
 template <> struct FoldingSetTrait<RetEffect> {
   static inline void Profile(const RetEffect &X, FoldingSetNodeID &ID) {
     ID.AddInteger((unsigned) X.getKind());
     ID.AddInteger((unsigned) X.getObjKind());
 }
 };
 
 template <> struct DenseMapInfo<ObjCSummaryKey> {
   static inline ObjCSummaryKey getEmptyKey() {
     return ObjCSummaryKey(DenseMapInfo<IdentifierInfo*>::getEmptyKey(),
                           DenseMapInfo<Selector>::getEmptyKey());
   }
 
   static inline ObjCSummaryKey getTombstoneKey() {
     return ObjCSummaryKey(DenseMapInfo<IdentifierInfo*>::getTombstoneKey(),
                           DenseMapInfo<Selector>::getTombstoneKey());
   }
 
   static unsigned getHashValue(const ObjCSummaryKey &V) {
     typedef std::pair<IdentifierInfo*, Selector> PairTy;
     return DenseMapInfo<PairTy>::getHashValue(PairTy(V.getIdentifier(),
                                                      V.getSelector()));
   }
 
   static bool isEqual(const ObjCSummaryKey& LHS, const ObjCSummaryKey& RHS) {
     return LHS.getIdentifier() == RHS.getIdentifier() &&
            LHS.getSelector() == RHS.getSelector();
   }
 
 };
 
 } // end llvm namespace
 
 
 namespace clang {
 namespace ento {
 
 /// ArgEffects summarizes the effects of a function/method call on all of
 /// its arguments.
 typedef llvm::ImmutableMap<unsigned, ArgEffect> ArgEffects;
 
 /// Summary for a function with respect to ownership changes.
 class RetainSummary {
   /// Args - a map of (index, ArgEffect) pairs, where index
   ///  specifies the argument (starting from 0).  This can be sparsely
   ///  populated; arguments with no entry in Args use 'DefaultArgEffect'.
   ArgEffects Args;
 
   /// DefaultArgEffect - The default ArgEffect to apply to arguments that
   ///  do not have an entry in Args.
   ArgEffect DefaultArgEffect;
 
   /// Receiver - If this summary applies to an Objective-C message expression,
   ///  this is the effect applied to the state of the receiver.
   ArgEffect Receiver;
 
   /// Effect on "this" pointer - applicable only to C++ method calls.
   ArgEffect This;
 
   /// Ret - The effect on the return value.  Used to indicate if the
   ///  function/method call returns a new tracked symbol.
   RetEffect Ret;
 
 public:
   RetainSummary(ArgEffects A,
                 RetEffect R,
                 ArgEffect defaultEff,
                 ArgEffect ReceiverEff,
                 ArgEffect ThisEff)
     : Args(A), DefaultArgEffect(defaultEff), Receiver(ReceiverEff),
       This(ThisEff), Ret(R) {}
 
   /// getArg - Return the argument effect on the argument specified by
   ///  idx (starting from 0).
   ArgEffect getArg(unsigned idx) const {
     if (const ArgEffect *AE = Args.lookup(idx))
       return *AE;
 
     return DefaultArgEffect;
   }
 
   void addArg(ArgEffects::Factory &af, unsigned idx, ArgEffect e) {
     Args = af.add(Args, idx, e);
   }
 
   /// setDefaultArgEffect - Set the default argument effect.
   void setDefaultArgEffect(ArgEffect E) {
     DefaultArgEffect = E;
   }
 
   /// getRetEffect - Returns the effect on the return value of the call.
   RetEffect getRetEffect() const { return Ret; }
 
   /// setRetEffect - Set the effect of the return value of the call.
   void setRetEffect(RetEffect E) { Ret = E; }
 
 
   /// Sets the effect on the receiver of the message.
   void setReceiverEffect(ArgEffect e) { Receiver = e; }
 
   /// getReceiverEffect - Returns the effect on the receiver of the call.
   ///  This is only meaningful if the summary applies to an ObjCMessageExpr*.
   ArgEffect getReceiverEffect() const { return Receiver; }
 
   /// \return the effect on the "this" receiver of the method call.
   /// This is only meaningful if the summary applies to CXXMethodDecl*.
   ArgEffect getThisEffect() const { return This; }
 
   ArgEffect getDefaultEffect() const { return DefaultArgEffect; }
 
   /// Set the effect of the method on "this".
   void setThisEffect(ArgEffect e) { This = e; }
 
   bool isNoop() const {
     return Ret == RetEffect::MakeNoRet() && Receiver.getKind() == DoNothing
       && DefaultArgEffect.getKind() == MayEscape && This.getKind() == DoNothing
       && Args.isEmpty();
   }
 
   /// Test if two retain summaries are identical. Note that merely equivalent
   /// summaries are not necessarily identical (for example, if an explicit
   /// argument effect matches the default effect).
   bool operator==(const RetainSummary &Other) const {
     return Args == Other.Args && DefaultArgEffect == Other.DefaultArgEffect &&
            Receiver == Other.Receiver && This == Other.This && Ret == Other.Ret;
   }
 
   /// Profile this summary for inclusion in a FoldingSet.
   void Profile(llvm::FoldingSetNodeID& ID) const {
     ID.Add(Args);
     ID.Add(DefaultArgEffect);
     ID.Add(Receiver);
     ID.Add(This);
     ID.Add(Ret);
   }
 
   /// A retain summary is simple if it has no ArgEffects other than the default.
   bool isSimple() const {
     return Args.isEmpty();
   }
 
   ArgEffects getArgEffects() const { return Args; }
 
 private:
   ArgEffect getDefaultArgEffect() const { return DefaultArgEffect; }
 
   friend class RetainSummaryManager;
 };
 
 class ObjCSummaryCache {
   typedef llvm::DenseMap<ObjCSummaryKey, const RetainSummary *> MapTy;
   MapTy M;
 public:
   ObjCSummaryCache() {}
 
   const RetainSummary * find(const ObjCInterfaceDecl *D, Selector S) {
     // Do a lookup with the (D,S) pair.  If we find a match return
     // the iterator.
     ObjCSummaryKey K(D, S);
     MapTy::iterator I = M.find(K);
 
     if (I != M.end())
       return I->second;
     if (!D)
       return nullptr;
 
     // Walk the super chain.  If we find a hit with a parent, we'll end
     // up returning that summary.  We actually allow that key (null,S), as
     // we cache summaries for the null ObjCInterfaceDecl* to allow us to
     // generate initial summaries without having to worry about NSObject
     // being declared.
     // FIXME: We may change this at some point.
     for (ObjCInterfaceDecl *C=D->getSuperClass() ;; C=C->getSuperClass()) {
       if ((I = M.find(ObjCSummaryKey(C, S))) != M.end())
         break;
 
       if (!C)
         return nullptr;
     }
 
     // Cache the summary with original key to make the next lookup faster
     // and return the iterator.
     const RetainSummary *Summ = I->second;
     M[K] = Summ;
     return Summ;
   }
 
   const RetainSummary *find(IdentifierInfo* II, Selector S) {
     // FIXME: Class method lookup.  Right now we don't have a good way
     // of going between IdentifierInfo* and the class hierarchy.
     MapTy::iterator I = M.find(ObjCSummaryKey(II, S));
 
     if (I == M.end())
       I = M.find(ObjCSummaryKey(S));
 
     return I == M.end() ? nullptr : I->second;
   }
 
   const RetainSummary *& operator[](ObjCSummaryKey K) {
     return M[K];
   }
 
   const RetainSummary *& operator[](Selector S) {
     return M[ ObjCSummaryKey(S) ];
   }
 };
 
 class RetainSummaryTemplate;
 
 class RetainSummaryManager {
   typedef llvm::DenseMap<const FunctionDecl*, const RetainSummary *>
           FuncSummariesTy;
 
   typedef ObjCSummaryCache ObjCMethodSummariesTy;
 
   typedef llvm::FoldingSetNodeWrapper<RetainSummary> CachedSummaryNode;
 
   /// Ctx - The ASTContext object for the analyzed ASTs.
   ASTContext &Ctx;
 
   /// Records whether or not the analyzed code runs in ARC mode.
   const bool ARCEnabled;
 
   /// Track Objective-C and CoreFoundation objects.
   const bool TrackObjCAndCFObjects;
 
   /// Track sublcasses of OSObject.
   const bool TrackOSObjects;
 
   /// FuncSummaries - A map from FunctionDecls to summaries.
   FuncSummariesTy FuncSummaries;
 
   /// ObjCClassMethodSummaries - A map from selectors (for instance methods)
   ///  to summaries.
   ObjCMethodSummariesTy ObjCClassMethodSummaries;
 
   /// ObjCMethodSummaries - A map from selectors to summaries.
   ObjCMethodSummariesTy ObjCMethodSummaries;
 
   /// BPAlloc - A BumpPtrAllocator used for allocating summaries, ArgEffects,
   ///  and all other data used by the checker.
   llvm::BumpPtrAllocator BPAlloc;
 
   /// AF - A factory for ArgEffects objects.
   ArgEffects::Factory AF;
 
   /// ObjCAllocRetE - Default return effect for methods returning Objective-C
   ///  objects.
   RetEffect ObjCAllocRetE;
 
   /// ObjCInitRetE - Default return effect for init methods returning
   ///   Objective-C objects.
   RetEffect ObjCInitRetE;
 
   /// SimpleSummaries - Used for uniquing summaries that don't have special
   /// effects.
   llvm::FoldingSet<CachedSummaryNode> SimpleSummaries;
 
   /// Create an OS object at +1.
   const RetainSummary *getOSSummaryCreateRule(const FunctionDecl *FD);
 
   /// Get an OS object at +0.
   const RetainSummary *getOSSummaryGetRule(const FunctionDecl *FD);
 
   /// Increment the reference count on OS object.
   const RetainSummary *getOSSummaryRetainRule(const FunctionDecl *FD);
 
   /// Decrement the reference count on OS object.
   const RetainSummary *getOSSummaryReleaseRule(const FunctionDecl *FD);
 
   /// Free the OS object.
   const RetainSummary *getOSSummaryFreeRule(const FunctionDecl *FD);
 
   const RetainSummary *getUnarySummary(const FunctionType* FT,
                                        ArgEffectKind AE);
 
   const RetainSummary *getCFSummaryCreateRule(const FunctionDecl *FD);
   const RetainSummary *getCFSummaryGetRule(const FunctionDecl *FD);
   const RetainSummary *getCFCreateGetRuleSummary(const FunctionDecl *FD);
 
   const RetainSummary *getPersistentSummary(const RetainSummary &OldSumm);
 
   const RetainSummary *
   getPersistentSummary(RetEffect RetEff, ArgEffects ScratchArgs,
                        ArgEffect ReceiverEff = ArgEffect(DoNothing),
                        ArgEffect DefaultEff = ArgEffect(MayEscape),
                        ArgEffect ThisEff = ArgEffect(DoNothing)) {
     RetainSummary Summ(ScratchArgs, RetEff, DefaultEff, ReceiverEff, ThisEff);
     return getPersistentSummary(Summ);
   }
 
   const RetainSummary *getDoNothingSummary() {
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ArgEffects(AF.getEmptyMap()),
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   }
 
   const RetainSummary *getDefaultSummary() {
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ArgEffects(AF.getEmptyMap()),
                                 ArgEffect(DoNothing), ArgEffect(MayEscape));
   }
 
   const RetainSummary *getPersistentStopSummary() {
     return getPersistentSummary(
         RetEffect::MakeNoRet(), ArgEffects(AF.getEmptyMap()),
         ArgEffect(StopTracking), ArgEffect(StopTracking));
   }
 
   void InitializeClassMethodSummaries();
   void InitializeMethodSummaries();
 
   void addNSObjectClsMethSummary(Selector S, const RetainSummary *Summ) {
     ObjCClassMethodSummaries[S] = Summ;
   }
 
   void addNSObjectMethSummary(Selector S, const RetainSummary *Summ) {
     ObjCMethodSummaries[S] = Summ;
   }
 
   void addClassMethSummary(const char* Cls, const char* name,
                            const RetainSummary *Summ, bool isNullary = true) {
     IdentifierInfo* ClsII = &Ctx.Idents.get(Cls);
     Selector S = isNullary ? GetNullarySelector(name, Ctx)
                            : GetUnarySelector(name, Ctx);
     ObjCClassMethodSummaries[ObjCSummaryKey(ClsII, S)]  = Summ;
   }
 
   void addInstMethSummary(const char* Cls, const char* nullaryName,
                           const RetainSummary *Summ) {
     IdentifierInfo* ClsII = &Ctx.Idents.get(Cls);
     Selector S = GetNullarySelector(nullaryName, Ctx);
     ObjCMethodSummaries[ObjCSummaryKey(ClsII, S)]  = Summ;
   }
 
   template <typename... Keywords>
   void addMethodSummary(IdentifierInfo *ClsII, ObjCMethodSummariesTy &Summaries,
                         const RetainSummary *Summ, Keywords *... Kws) {
     Selector S = getKeywordSelector(Ctx, Kws...);
     Summaries[ObjCSummaryKey(ClsII, S)] = Summ;
   }
 
   template <typename... Keywords>
   void addInstMethSummary(const char *Cls, const RetainSummary *Summ,
                           Keywords *... Kws) {
     addMethodSummary(&Ctx.Idents.get(Cls), ObjCMethodSummaries, Summ, Kws...);
   }
 
   template <typename... Keywords>
   void addClsMethSummary(const char *Cls, const RetainSummary *Summ,
                          Keywords *... Kws) {
     addMethodSummary(&Ctx.Idents.get(Cls), ObjCClassMethodSummaries, Summ,
                      Kws...);
   }
 
   template <typename... Keywords>
   void addClsMethSummary(IdentifierInfo *II, const RetainSummary *Summ,
                          Keywords *... Kws) {
     addMethodSummary(II, ObjCClassMethodSummaries, Summ, Kws...);
   }
 
   const RetainSummary * generateSummary(const FunctionDecl *FD,
                                         bool &AllowAnnotations);
 
   /// Return a summary for OSObject, or nullptr if not found.
   const RetainSummary *getSummaryForOSObject(const FunctionDecl *FD,
                                              StringRef FName, QualType RetTy);
 
   /// Return a summary for Objective-C or CF object, or nullptr if not found.
   const RetainSummary *getSummaryForObjCOrCFObject(
     const FunctionDecl *FD,
     StringRef FName,
     QualType RetTy,
     const FunctionType *FT,
     bool &AllowAnnotations);
 
   /// Apply the annotation of @c pd in function @c FD
   /// to the resulting summary stored in out-parameter @c Template.
   /// \return whether an annotation was applied.
   bool applyParamAnnotationEffect(const ParmVarDecl *pd, unsigned parm_idx,
                                   const NamedDecl *FD,
                                   RetainSummaryTemplate &Template);
 
 public:
   RetainSummaryManager(ASTContext &ctx, bool trackObjCAndCFObjects,
                        bool trackOSObjects)
       : Ctx(ctx), ARCEnabled((bool)Ctx.getLangOpts().ObjCAutoRefCount),
         TrackObjCAndCFObjects(trackObjCAndCFObjects),
         TrackOSObjects(trackOSObjects), AF(BPAlloc),
         ObjCAllocRetE(ARCEnabled ? RetEffect::MakeNotOwned(ObjKind::ObjC)
                                  : RetEffect::MakeOwned(ObjKind::ObjC)),
         ObjCInitRetE(ARCEnabled ? RetEffect::MakeNotOwned(ObjKind::ObjC)
                                 : RetEffect::MakeOwnedWhenTrackedReceiver()) {
     InitializeClassMethodSummaries();
     InitializeMethodSummaries();
   }
 
   enum class BehaviorSummary {
     // Function does not return.
     NoOp,
 
     // Function returns the first argument.
     Identity,
 
     // Function returns "this" argument.
     IdentityThis,
 
     // Function either returns zero, or the input parameter.
     IdentityOrZero
   };
 
   std::optional<BehaviorSummary>
   canEval(const CallExpr *CE, const FunctionDecl *FD,
           bool &hasTrustedImplementationAnnotation);
 
   /// \return Whether the type corresponds to a known smart pointer
   /// implementation (that is, everything about it is inlineable).
   static bool isKnownSmartPointer(QualType QT);
 
   bool isTrustedReferenceCountImplementation(const Decl *FD);
 
   const RetainSummary *getSummary(AnyCall C,
                                   bool HasNonZeroCallbackArg=false,
                                   bool IsReceiverUnconsumedSelf=false,
                                   QualType ReceiverType={});
 
   RetEffect getObjAllocRetEffect() const { return ObjCAllocRetE; }
 
 private:
 
   /// getMethodSummary - This version of getMethodSummary is used to query
   ///  the summary for the current method being analyzed.
   const RetainSummary *getMethodSummary(const ObjCMethodDecl *MD);
 
   const RetainSummary *getFunctionSummary(const FunctionDecl *FD);
 
   const RetainSummary *getMethodSummary(Selector S, const ObjCInterfaceDecl *ID,
                                         const ObjCMethodDecl *MD,
                                         QualType RetTy,
                                         ObjCMethodSummariesTy &CachedSummaries);
 
   const RetainSummary *
   getInstanceMethodSummary(const ObjCMessageExpr *ME, QualType ReceiverType);
 
   const RetainSummary *getClassMethodSummary(const ObjCMessageExpr *ME);
 
   const RetainSummary *getStandardMethodSummary(const ObjCMethodDecl *MD,
                                                 Selector S, QualType RetTy);
 
   /// Determine if there is a special return effect for this function or method.
   std::optional<RetEffect> getRetEffectFromAnnotations(QualType RetTy,
                                                        const Decl *D);
 
   void updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                     const ObjCMethodDecl *MD);
 
   void updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                     const FunctionDecl *FD);
 
   const RetainSummary *updateSummaryForNonZeroCallbackArg(const RetainSummary *S,
                                                           AnyCall &C);
 
   /// Special case '[super init];' and '[self init];'
   ///
   /// Even though calling '[super init]' without assigning the result to self
   /// and checking if the parent returns 'nil' is a bad pattern, it is common.
   /// Additionally, our Self Init checker already warns about it. To avoid
   /// overwhelming the user with messages from both checkers, we model the case
   /// of '[super init]' in cases when it is not consumed by another expression
   /// as if the call preserves the value of 'self'; essentially, assuming it can
   /// never fail and return 'nil'.
   /// Note, we don't want to just stop tracking the value since we want the
   /// RetainCount checker to report leaks and use-after-free if SelfInit checker
   /// is turned off.
   void updateSummaryForReceiverUnconsumedSelf(const RetainSummary *&S);
 
   /// Set argument types for arguments which are not doing anything.
   void updateSummaryForArgumentTypes(const AnyCall &C, const RetainSummary *&RS);
 
   /// Determine whether a declaration @c D of correspondent type (return
   /// type for functions/methods) @c QT has any of the given attributes,
   /// provided they pass necessary validation checks AND tracking the given
   /// attribute is enabled.
   /// Returns the object kind corresponding to the present attribute, or
   /// std::nullopt, if none of the specified attributes are present.
   /// Crashes if passed an attribute which is not explicitly handled.
   template <class T>
   std::optional<ObjKind> hasAnyEnabledAttrOf(const Decl *D, QualType QT);
 
   template <class T1, class T2, class... Others>
   std::optional<ObjKind> hasAnyEnabledAttrOf(const Decl *D, QualType QT);
 
   friend class RetainSummaryTemplate;
 };
 
 
 // Used to avoid allocating long-term (BPAlloc'd) memory for default retain
 // summaries. If a function or method looks like it has a default summary, but
 // it has annotations, the annotations are added to the stack-based template
 // and then copied into managed memory.
 class RetainSummaryTemplate {
   RetainSummaryManager &Manager;
   const RetainSummary *&RealSummary;
   RetainSummary ScratchSummary;
   bool Accessed;
 public:
   RetainSummaryTemplate(const RetainSummary *&real, RetainSummaryManager &mgr)
     : Manager(mgr), RealSummary(real), ScratchSummary(*real), Accessed(false) {}
 
   ~RetainSummaryTemplate() {
     if (Accessed)
       RealSummary = Manager.getPersistentSummary(ScratchSummary);
   }
 
   RetainSummary &operator*() {
     Accessed = true;
     return ScratchSummary;
   }
 
   RetainSummary *operator->() {
     Accessed = true;
     return &ScratchSummary;
   }
 };
 
 } // end namespace ento
 } // end namespace clang
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team