LCOV - code coverage report
Current view: top level - include/llvm/Analysis - ObjCARCAnalysisUtils.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 80 89 89.9 %
Date: 2018-10-14 09:39:32 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- ObjCARCAnalysisUtils.h - ObjC ARC Analysis Utilities -----*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : /// \file
      10             : /// This file defines common analysis utilities used by the ObjC ARC Optimizer.
      11             : /// ARC stands for Automatic Reference Counting and is a system for managing
      12             : /// reference counts for objects in Objective C.
      13             : ///
      14             : /// WARNING: This file knows about certain library functions. It recognizes them
      15             : /// by name, and hardwires knowledge of their semantics.
      16             : ///
      17             : /// WARNING: This file knows about how certain Objective-C library functions are
      18             : /// used. Naive LLVM IR transformations which would otherwise be
      19             : /// behavior-preserving may break these assumptions.
      20             : ///
      21             : //===----------------------------------------------------------------------===//
      22             : 
      23             : #ifndef LLVM_LIB_ANALYSIS_OBJCARCANALYSISUTILS_H
      24             : #define LLVM_LIB_ANALYSIS_OBJCARCANALYSISUTILS_H
      25             : 
      26             : #include "llvm/ADT/Optional.h"
      27             : #include "llvm/ADT/StringSwitch.h"
      28             : #include "llvm/Analysis/AliasAnalysis.h"
      29             : #include "llvm/Analysis/ObjCARCInstKind.h"
      30             : #include "llvm/Analysis/Passes.h"
      31             : #include "llvm/Analysis/ValueTracking.h"
      32             : #include "llvm/IR/CallSite.h"
      33             : #include "llvm/IR/Constants.h"
      34             : #include "llvm/IR/InstIterator.h"
      35             : #include "llvm/IR/LLVMContext.h"
      36             : #include "llvm/IR/Module.h"
      37             : #include "llvm/IR/ValueHandle.h"
      38             : #include "llvm/Pass.h"
      39             : 
      40             : namespace llvm {
      41             : class raw_ostream;
      42             : }
      43             : 
      44             : namespace llvm {
      45             : namespace objcarc {
      46             : 
      47             : /// A handy option to enable/disable all ARC Optimizations.
      48             : extern bool EnableARCOpts;
      49             : 
      50             : /// Test if the given module looks interesting to run ARC optimization
      51             : /// on.
      52         460 : inline bool ModuleHasARC(const Module &M) {
      53             :   return
      54         882 :     M.getNamedValue("objc_retain") ||
      55         830 :     M.getNamedValue("objc_release") ||
      56         816 :     M.getNamedValue("objc_autorelease") ||
      57         815 :     M.getNamedValue("objc_retainAutoreleasedReturnValue") ||
      58         814 :     M.getNamedValue("objc_unsafeClaimAutoreleasedReturnValue") ||
      59         814 :     M.getNamedValue("objc_retainBlock") ||
      60         813 :     M.getNamedValue("objc_autoreleaseReturnValue") ||
      61         810 :     M.getNamedValue("objc_autoreleasePoolPush") ||
      62         805 :     M.getNamedValue("objc_loadWeakRetained") ||
      63         802 :     M.getNamedValue("objc_loadWeak") ||
      64         802 :     M.getNamedValue("objc_destroyWeak") ||
      65         802 :     M.getNamedValue("objc_storeWeak") ||
      66         801 :     M.getNamedValue("objc_initWeak") ||
      67         800 :     M.getNamedValue("objc_moveWeak") ||
      68         800 :     M.getNamedValue("objc_copyWeak") ||
      69         800 :     M.getNamedValue("objc_retainedObject") ||
      70         800 :     M.getNamedValue("objc_unretainedObject") ||
      71        1260 :     M.getNamedValue("objc_unretainedPointer") ||
      72         400 :     M.getNamedValue("clang.arc.use");
      73             : }
      74             : 
      75             : /// This is a wrapper around getUnderlyingObject which also knows how to
      76             : /// look through objc_retain and objc_autorelease calls, which we know to return
      77             : /// their argument verbatim.
      78        4766 : inline const Value *GetUnderlyingObjCPtr(const Value *V,
      79             :                                                 const DataLayout &DL) {
      80             :   for (;;) {
      81             :     V = GetUnderlyingObject(V, DL);
      82        4825 :     if (!IsForwarding(GetBasicARCInstKind(V)))
      83             :       break;
      84          59 :     V = cast<CallInst>(V)->getArgOperand(0);
      85             :   }
      86             : 
      87        4766 :   return V;
      88             : }
      89             : 
      90             : /// A wrapper for GetUnderlyingObjCPtr used for results memoization.
      91             : inline const Value *
      92        2800 : GetUnderlyingObjCPtrCached(const Value *V, const DataLayout &DL,
      93             :                            DenseMap<const Value *, WeakTrackingVH> &Cache) {
      94        2800 :   if (auto InCache = Cache.lookup(V))
      95             :     return InCache;
      96             : 
      97         538 :   const Value *Computed = GetUnderlyingObjCPtr(V, DL);
      98             :   Cache[V] = const_cast<Value *>(Computed);
      99         538 :   return Computed;
     100             : }
     101             : 
     102             : /// The RCIdentity root of a value \p V is a dominating value U for which
     103             : /// retaining or releasing U is equivalent to retaining or releasing V. In other
     104             : /// words, ARC operations on \p V are equivalent to ARC operations on \p U.
     105             : ///
     106             : /// We use this in the ARC optimizer to make it easier to match up ARC
     107             : /// operations by always mapping ARC operations to RCIdentityRoots instead of
     108             : /// pointers themselves.
     109             : ///
     110             : /// The two ways that we see RCIdentical values in ObjC are via:
     111             : ///
     112             : ///   1. PointerCasts
     113             : ///   2. Forwarding Calls that return their argument verbatim.
     114             : ///
     115             : /// Thus this function strips off pointer casts and forwarding calls. *NOTE*
     116             : /// This implies that two RCIdentical values must alias.
     117        7172 : inline const Value *GetRCIdentityRoot(const Value *V) {
     118             :   for (;;) {
     119        7646 :     V = V->stripPointerCasts();
     120        7646 :     if (!IsForwarding(GetBasicARCInstKind(V)))
     121             :       break;
     122         474 :     V = cast<CallInst>(V)->getArgOperand(0);
     123             :   }
     124        7172 :   return V;
     125             : }
     126             : 
     127             : /// Helper which calls const Value *GetRCIdentityRoot(const Value *V) and just
     128             : /// casts away the const of the result. For documentation about what an
     129             : /// RCIdentityRoot (and by extension GetRCIdentityRoot is) look at that
     130             : /// function.
     131             : inline Value *GetRCIdentityRoot(Value *V) {
     132        2420 :   return const_cast<Value *>(GetRCIdentityRoot((const Value *)V));
     133             : }
     134             : 
     135             : /// Assuming the given instruction is one of the special calls such as
     136             : /// objc_retain or objc_release, return the RCIdentity root of the argument of
     137             : /// the call.
     138             : inline Value *GetArgRCIdentityRoot(Value *Inst) {
     139        2306 :   return GetRCIdentityRoot(cast<CallInst>(Inst)->getArgOperand(0));
     140             : }
     141             : 
     142             : inline bool IsNullOrUndef(const Value *V) {
     143         884 :   return isa<ConstantPointerNull>(V) || isa<UndefValue>(V);
     144             : }
     145             : 
     146             : inline bool IsNoopInstruction(const Instruction *I) {
     147           0 :   return isa<BitCastInst>(I) ||
     148           0 :     (isa<GetElementPtrInst>(I) &&
     149           0 :      cast<GetElementPtrInst>(I)->hasAllZeroIndices());
     150             : }
     151             : 
     152             : /// Test whether the given value is possible a retainable object pointer.
     153        4331 : inline bool IsPotentialRetainableObjPtr(const Value *Op) {
     154             :   // Pointers to static or stack storage are not valid retainable object
     155             :   // pointers.
     156        4331 :   if (isa<Constant>(Op) || isa<AllocaInst>(Op))
     157             :     return false;
     158             :   // Special arguments can not be a valid retainable object pointer.
     159             :   if (const Argument *Arg = dyn_cast<Argument>(Op))
     160        1150 :     if (Arg->hasByValAttr() ||
     161        1150 :         Arg->hasInAllocaAttr() ||
     162        1725 :         Arg->hasNestAttr() ||
     163         575 :         Arg->hasStructRetAttr())
     164           0 :       return false;
     165             :   // Only consider values with pointer types.
     166             :   //
     167             :   // It seemes intuitive to exclude function pointer types as well, since
     168             :   // functions are never retainable object pointers, however clang occasionally
     169             :   // bitcasts retainable object pointers to function-pointer type temporarily.
     170        2433 :   PointerType *Ty = dyn_cast<PointerType>(Op->getType());
     171             :   if (!Ty)
     172         146 :     return false;
     173             :   // Conservatively assume anything else is a potential retainable object
     174             :   // pointer.
     175             :   return true;
     176             : }
     177             : 
     178        1076 : inline bool IsPotentialRetainableObjPtr(const Value *Op,
     179             :                                                AliasAnalysis &AA) {
     180             :   // First make the rudimentary check.
     181        1076 :   if (!IsPotentialRetainableObjPtr(Op))
     182             :     return false;
     183             : 
     184             :   // Objects in constant memory are not reference-counted.
     185         949 :   if (AA.pointsToConstantMemory(Op))
     186             :     return false;
     187             : 
     188             :   // Pointers in constant memory are not pointing to reference-counted objects.
     189             :   if (const LoadInst *LI = dyn_cast<LoadInst>(Op))
     190         207 :     if (AA.pointsToConstantMemory(LI->getPointerOperand()))
     191          17 :       return false;
     192             : 
     193             :   // Otherwise assume the worst.
     194             :   return true;
     195             : }
     196             : 
     197             : /// Helper for GetARCInstKind. Determines what kind of construct CS
     198             : /// is.
     199        1167 : inline ARCInstKind GetCallSiteClass(ImmutableCallSite CS) {
     200        2200 :   for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
     201        2200 :        I != E; ++I)
     202        1589 :     if (IsPotentialRetainableObjPtr(*I))
     203         556 :       return CS.onlyReadsMemory() ? ARCInstKind::User : ARCInstKind::CallOrUser;
     204             : 
     205         611 :   return CS.onlyReadsMemory() ? ARCInstKind::None : ARCInstKind::Call;
     206             : }
     207             : 
     208             : /// Return true if this value refers to a distinct and identifiable
     209             : /// object.
     210             : ///
     211             : /// This is similar to AliasAnalysis's isIdentifiedObject, except that it uses
     212             : /// special knowledge of ObjC conventions.
     213        1309 : inline bool IsObjCIdentifiedObject(const Value *V) {
     214             :   // Assume that call results and arguments have their own "provenance".
     215             :   // Constants (including GlobalVariables) and Allocas are never
     216             :   // reference-counted.
     217         990 :   if (isa<CallInst>(V) || isa<InvokeInst>(V) ||
     218         757 :       isa<Argument>(V) || isa<Constant>(V) ||
     219             :       isa<AllocaInst>(V))
     220             :     return true;
     221             : 
     222             :   if (const LoadInst *LI = dyn_cast<LoadInst>(V)) {
     223             :     const Value *Pointer =
     224         429 :       GetRCIdentityRoot(LI->getPointerOperand());
     225             :     if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Pointer)) {
     226             :       // A constant pointer can't be pointing to an object on the heap. It may
     227             :       // be reference-counted, but it won't be deleted.
     228         264 :       if (GV->isConstant())
     229         159 :         return true;
     230         260 :       StringRef Name = GV->getName();
     231             :       // These special variables are known to hold values which are not
     232             :       // reference-counted pointers.
     233             :       if (Name.startswith("\01l_objc_msgSend_fixup_"))
     234             :         return true;
     235             : 
     236         477 :       StringRef Section = GV->getSection();
     237         466 :       if (Section.find("__message_refs") != StringRef::npos ||
     238         383 :           Section.find("__objc_classrefs") != StringRef::npos ||
     239         300 :           Section.find("__objc_superrefs") != StringRef::npos ||
     240         506 :           Section.find("__objc_methname") != StringRef::npos ||
     241         228 :           Section.find("__cstring") != StringRef::npos)
     242         137 :         return true;
     243             :     }
     244             :   }
     245             : 
     246             :   return false;
     247             : }
     248             : 
     249             : enum class ARCMDKindID {
     250             :   ImpreciseRelease,
     251             :   CopyOnEscape,
     252             :   NoObjCARCExceptions,
     253             : };
     254             : 
     255             : /// A cache of MDKinds used by various ARC optimizations.
     256             : class ARCMDKindCache {
     257             :   Module *M;
     258             : 
     259             :   /// The Metadata Kind for clang.imprecise_release metadata.
     260             :   llvm::Optional<unsigned> ImpreciseReleaseMDKind;
     261             : 
     262             :   /// The Metadata Kind for clang.arc.copy_on_escape metadata.
     263             :   llvm::Optional<unsigned> CopyOnEscapeMDKind;
     264             : 
     265             :   /// The Metadata Kind for clang.arc.no_objc_arc_exceptions metadata.
     266             :   llvm::Optional<unsigned> NoObjCARCExceptionsMDKind;
     267             : 
     268             : public:
     269             :   void init(Module *Mod) {
     270          31 :     M = Mod;
     271             :     ImpreciseReleaseMDKind = NoneType::None;
     272             :     CopyOnEscapeMDKind = NoneType::None;
     273             :     NoObjCARCExceptionsMDKind = NoneType::None;
     274             :   }
     275             : 
     276        1197 :   unsigned get(ARCMDKindID ID) {
     277        1197 :     switch (ID) {
     278        1000 :     case ARCMDKindID::ImpreciseRelease:
     279        1000 :       if (!ImpreciseReleaseMDKind)
     280             :         ImpreciseReleaseMDKind =
     281          84 :             M->getContext().getMDKindID("clang.imprecise_release");
     282        1000 :       return *ImpreciseReleaseMDKind;
     283           0 :     case ARCMDKindID::CopyOnEscape:
     284           0 :       if (!CopyOnEscapeMDKind)
     285             :         CopyOnEscapeMDKind =
     286           0 :             M->getContext().getMDKindID("clang.arc.copy_on_escape");
     287           0 :       return *CopyOnEscapeMDKind;
     288         197 :     case ARCMDKindID::NoObjCARCExceptions:
     289         197 :       if (!NoObjCARCExceptionsMDKind)
     290             :         NoObjCARCExceptionsMDKind =
     291          75 :             M->getContext().getMDKindID("clang.arc.no_objc_arc_exceptions");
     292         197 :       return *NoObjCARCExceptionsMDKind;
     293             :     }
     294           0 :     llvm_unreachable("Covered switch isn't covered?!");
     295             :   }
     296             : };
     297             : 
     298             : } // end namespace objcarc
     299             : } // end namespace llvm
     300             : 
     301             : #endif

Generated by: LCOV version 1.13