llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp

   1 //===- ObjCARCAliasAnalysis.cpp - ObjC ARC Optimization -------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 /// \file
   9 /// This file defines a simple ARC-aware AliasAnalysis using special knowledge
  10 /// of Objective C to enhance other optimization passes which rely on the Alias
  11 /// Analysis infrastructure.
  12 ///
  13 /// WARNING: This file knows about certain library functions. It recognizes them
  14 /// by name, and hardwires knowledge of their semantics.
  15 ///
  16 /// WARNING: This file knows about how certain Objective-C library functions are
  17 /// used. Naive LLVM IR transformations which would otherwise be
  18 /// behavior-preserving may break these assumptions.
  19 ///
  20 /// TODO: Theoretically we could check for dependencies between objc_* calls
  21 /// and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls.
  22 ///
  23 //===----------------------------------------------------------------------===//
  24
  25 #include "llvm/Analysis/ObjCARCAliasAnalysis.h"
  26 #include "llvm/Analysis/ObjCARCAnalysisUtils.h"
  27 #include "llvm/Analysis/Passes.h"
  28 #include "llvm/IR/Function.h"
  29 #include "llvm/IR/Instruction.h"
  30 #include "llvm/IR/Value.h"
  31 #include "llvm/InitializePasses.h"
  32 #include "llvm/Pass.h"
  33
  34 #define DEBUG_TYPE "objc-arc-aa"
  35
  36 using namespace llvm;
  37 using namespace llvm::objcarc;
  38
  39 AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA,
  40                                    const MemoryLocation &LocB,
  41                                    AAQueryInfo &AAQI) {
  42   if (!EnableARCOpts)
  43     return AAResultBase::alias(LocA, LocB, AAQI);
  44
  45   // First, strip off no-ops, including ObjC-specific no-ops, and try making a
  46   // precise alias query.
  47   const Value *SA = GetRCIdentityRoot(LocA.Ptr);
  48   const Value *SB = GetRCIdentityRoot(LocB.Ptr);
  49   AliasResult Result =
  50       AAResultBase::alias(MemoryLocation(SA, LocA.Size, LocA.AATags),
  51                           MemoryLocation(SB, LocB.Size, LocB.AATags), AAQI);
  52   if (Result != AliasResult::MayAlias)
  53     return Result;
  54
  55   // If that failed, climb to the underlying object, including climbing through
  56   // ObjC-specific no-ops, and try making an imprecise alias query.
  57   const Value *UA = GetUnderlyingObjCPtr(SA);
  58   const Value *UB = GetUnderlyingObjCPtr(SB);
  59   if (UA != SA || UB != SB) {
  60     Result = AAResultBase::alias(MemoryLocation::getBeforeOrAfter(UA),
  61                                  MemoryLocation::getBeforeOrAfter(UB), AAQI);
  62     // We can't use MustAlias or PartialAlias results here because
  63     // GetUnderlyingObjCPtr may return an offsetted pointer value.
  64     if (Result == AliasResult::NoAlias)
  65       return AliasResult::NoAlias;
  66   }
  67
  68   // If that failed, fail. We don't need to chain here, since that's covered
  69   // by the earlier precise query.
  70   return AliasResult::MayAlias;
  71 }
  72
  73 bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
  74                                              AAQueryInfo &AAQI, bool OrLocal) {
  75   if (!EnableARCOpts)
  76     return AAResultBase::pointsToConstantMemory(Loc, AAQI, OrLocal);
  77
  78   // First, strip off no-ops, including ObjC-specific no-ops, and try making
  79   // a precise alias query.
  80   const Value *S = GetRCIdentityRoot(Loc.Ptr);
  81   if (AAResultBase::pointsToConstantMemory(
  82           MemoryLocation(S, Loc.Size, Loc.AATags), AAQI, OrLocal))
  83     return true;
  84
  85   // If that failed, climb to the underlying object, including climbing through
  86   // ObjC-specific no-ops, and try making an imprecise alias query.
  87   const Value *U = GetUnderlyingObjCPtr(S);
  88   if (U != S)
  89     return AAResultBase::pointsToConstantMemory(
  90         MemoryLocation::getBeforeOrAfter(U), AAQI, OrLocal);
  91
  92   // If that failed, fail. We don't need to chain here, since that's covered
  93   // by the earlier precise query.
  94   return false;
  95 }
  96
  97 FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
  98   if (!EnableARCOpts)
  99     return AAResultBase::getModRefBehavior(F);
 100
 101   switch (GetFunctionClass(F)) {
 102   case ARCInstKind::NoopCast:
 103     return FMRB_DoesNotAccessMemory;
 104   default:
 105     break;
 106   }
 107
 108   return AAResultBase::getModRefBehavior(F);
 109 }
 110
 111 ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call,
 112                                           const MemoryLocation &Loc,
 113                                           AAQueryInfo &AAQI) {
 114   if (!EnableARCOpts)
 115     return AAResultBase::getModRefInfo(Call, Loc, AAQI);
 116
 117   switch (GetBasicARCInstKind(Call)) {
 118   case ARCInstKind::Retain:
 119   case ARCInstKind::RetainRV:
 120   case ARCInstKind::Autorelease:
 121   case ARCInstKind::AutoreleaseRV:
 122   case ARCInstKind::NoopCast:
 123   case ARCInstKind::AutoreleasepoolPush:
 124   case ARCInstKind::FusedRetainAutorelease:
 125   case ARCInstKind::FusedRetainAutoreleaseRV:
 126     // These functions don't access any memory visible to the compiler.
 127     // Note that this doesn't include objc_retainBlock, because it updates
 128     // pointers when it copies block data.
 129     return ModRefInfo::NoModRef;
 130   default:
 131     break;
 132   }
 133
 134   return AAResultBase::getModRefInfo(Call, Loc, AAQI);
 135 }
 136
 137 AnalysisKey ObjCARCAA::Key;
 138
 139 ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) {
 140   return ObjCARCAAResult(F.getParent()->getDataLayout());
 141 }
 142
 143 char ObjCARCAAWrapperPass::ID = 0;
 144 INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa",
 145                 "ObjC-ARC-Based Alias Analysis", false, true)
 146
 147 ImmutablePass *llvm::createObjCARCAAWrapperPass() {
 148   return new ObjCARCAAWrapperPass();
 149 }
 150
 151 ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
 152   initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
 153 }
 154
 155 bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
 156   Result.reset(new ObjCARCAAResult(M.getDataLayout()));
 157   return false;
 158 }
 159
 160 bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
 161   Result.reset();
 162   return false;
 163 }
 164
 165 void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
 166   AU.setPreservesAll();
 167 }