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
36using namespace llvm;
37using namespace llvm::objcarc;
38
39AliasResult 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 != 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, DL);
58  const Value *UB = GetUnderlyingObjCPtr(SB, DL);
59  if (UA != SA || UB != SB) {
60    Result = AAResultBase::alias(MemoryLocation(UA), MemoryLocation(UB), AAQI);
61    // We can't use MustAlias or PartialAlias results here because
62    // GetUnderlyingObjCPtr may return an offsetted pointer value.
63    if (Result == NoAlias)
64      return NoAlias;
65  }
66
67  // If that failed, fail. We don't need to chain here, since that's covered
68  // by the earlier precise query.
69  return MayAlias;
70}
71
72bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
73                                             AAQueryInfo &AAQI, bool OrLocal) {
74  if (!EnableARCOpts)
75    return AAResultBase::pointsToConstantMemory(Loc, AAQI, OrLocal);
76
77  // First, strip off no-ops, including ObjC-specific no-ops, and try making
78  // a precise alias query.
79  const Value *S = GetRCIdentityRoot(Loc.Ptr);
80  if (AAResultBase::pointsToConstantMemory(
81          MemoryLocation(S, Loc.Size, Loc.AATags), AAQI, OrLocal))
82    return true;
83
84  // If that failed, climb to the underlying object, including climbing through
85  // ObjC-specific no-ops, and try making an imprecise alias query.
86  const Value *U = GetUnderlyingObjCPtr(S, DL);
87  if (U != S)
88    return AAResultBase::pointsToConstantMemory(MemoryLocation(U), AAQI,
89                                                OrLocal);
90
91  // If that failed, fail. We don't need to chain here, since that's covered
92  // by the earlier precise query.
93  return false;
94}
95
96FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
97  if (!EnableARCOpts)
98    return AAResultBase::getModRefBehavior(F);
99
100  switch (GetFunctionClass(F)) {
101  case ARCInstKind::NoopCast:
102    return FMRB_DoesNotAccessMemory;
103  default:
104    break;
105  }
106
107  return AAResultBase::getModRefBehavior(F);
108}
109
110ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call,
111                                          const MemoryLocation &Loc,
112                                          AAQueryInfo &AAQI) {
113  if (!EnableARCOpts)
114    return AAResultBase::getModRefInfo(Call, Loc, AAQI);
115
116  switch (GetBasicARCInstKind(Call)) {
117  case ARCInstKind::Retain:
118  case ARCInstKind::RetainRV:
119  case ARCInstKind::Autorelease:
120  case ARCInstKind::AutoreleaseRV:
121  case ARCInstKind::NoopCast:
122  case ARCInstKind::AutoreleasepoolPush:
123  case ARCInstKind::FusedRetainAutorelease:
124  case ARCInstKind::FusedRetainAutoreleaseRV:
125    // These functions don't access any memory visible to the compiler.
126    // Note that this doesn't include objc_retainBlock, because it updates
127    // pointers when it copies block data.
128    return ModRefInfo::NoModRef;
129  default:
130    break;
131  }
132
133  return AAResultBase::getModRefInfo(Call, Loc, AAQI);
134}
135
136ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) {
137  return ObjCARCAAResult(F.getParent()->getDataLayout());
138}
139
140char ObjCARCAAWrapperPass::ID = 0;
141INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa",
142                "ObjC-ARC-Based Alias Analysis", false, true)
143
144ImmutablePass *llvm::createObjCARCAAWrapperPass() {
145  return new ObjCARCAAWrapperPass();
146}
147
148ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
149  initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
150}
151
152bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
153  Result.reset(new ObjCARCAAResult(M.getDataLayout()));
154  return false;
155}
156
157bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
158  Result.reset();
159  return false;
160}
161
162void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
163  AU.setPreservesAll();
164}
165