1//===- ObjCARC.h - ObjC ARC Optimization --------------*- C++ -*-----------===//
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 common definitions/declarations used by the ObjC ARC
10/// Optimizer. ARC stands for Automatic Reference Counting and is a system for
11/// managing reference counts for objects in Objective C.
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//===----------------------------------------------------------------------===//
21
22#ifndef LLVM_LIB_TRANSFORMS_OBJCARC_OBJCARC_H
23#define LLVM_LIB_TRANSFORMS_OBJCARC_OBJCARC_H
24
25#include "llvm/Analysis/ObjCARCAnalysisUtils.h"
26#include "llvm/Analysis/ObjCARCUtil.h"
27#include "llvm/IR/EHPersonalities.h"
28#include "llvm/Transforms/Utils/Local.h"
29
30namespace llvm {
31namespace objcarc {
32
33/// Erase the given instruction.
34///
35/// Many ObjC calls return their argument verbatim,
36/// so if it's such a call and the return value has users, replace them with the
37/// argument value.
38///
39static inline void EraseInstruction(Instruction *CI) {
40  Value *OldArg = cast<CallInst>(CI)->getArgOperand(0);
41
42  bool Unused = CI->use_empty();
43
44  if (!Unused) {
45    // Replace the return value with the argument.
46    assert((IsForwarding(GetBasicARCInstKind(CI)) ||
47            (IsNoopOnNull(GetBasicARCInstKind(CI)) &&
48             IsNullOrUndef(OldArg->stripPointerCasts()))) &&
49           "Can't delete non-forwarding instruction with users!");
50    CI->replaceAllUsesWith(OldArg);
51  }
52
53  CI->eraseFromParent();
54
55  if (Unused)
56    RecursivelyDeleteTriviallyDeadInstructions(OldArg);
57}
58
59/// If Inst is a ReturnRV and its operand is a call or invoke, return the
60/// operand. Otherwise return null.
61static inline const Instruction *getreturnRVOperand(const Instruction &Inst,
62                                                    ARCInstKind Class) {
63  if (Class != ARCInstKind::RetainRV)
64    return nullptr;
65
66  const auto *Opnd = Inst.getOperand(0)->stripPointerCasts();
67  if (const auto *C = dyn_cast<CallInst>(Opnd))
68    return C;
69  return dyn_cast<InvokeInst>(Opnd);
70}
71
72/// Return the list of PHI nodes that are equivalent to PN.
73template<class PHINodeTy, class VectorTy>
74void getEquivalentPHIs(PHINodeTy &PN, VectorTy &PHIList) {
75  auto *BB = PN.getParent();
76  for (auto &P : BB->phis()) {
77    if (&P == &PN) // Do not add PN to the list.
78      continue;
79    unsigned I = 0, E = PN.getNumIncomingValues();
80    for (; I < E; ++I) {
81      auto *BB = PN.getIncomingBlock(I);
82      auto *PNOpnd = PN.getIncomingValue(I)->stripPointerCasts();
83      auto *POpnd = P.getIncomingValueForBlock(BB)->stripPointerCasts();
84      if (PNOpnd != POpnd)
85        break;
86    }
87    if (I == E)
88      PHIList.push_back(&P);
89  }
90}
91
92static inline MDString *getRVInstMarker(Module &M) {
93  const char *MarkerKey = getRVMarkerModuleFlagStr();
94  return dyn_cast_or_null<MDString>(M.getModuleFlag(MarkerKey));
95}
96
97/// Create a call instruction with the correct funclet token. This should be
98/// called instead of calling CallInst::Create directly unless the call is
99/// going to be removed from the IR before WinEHPrepare.
100CallInst *createCallInstWithColors(
101    FunctionCallee Func, ArrayRef<Value *> Args, const Twine &NameStr,
102    Instruction *InsertBefore,
103    const DenseMap<BasicBlock *, ColorVector> &BlockColors);
104
105class BundledRetainClaimRVs {
106public:
107  BundledRetainClaimRVs(bool ContractPass) : ContractPass(ContractPass) {}
108  ~BundledRetainClaimRVs();
109
110  /// Insert a retainRV/claimRV call to the normal destination blocks of invokes
111  /// with operand bundle "clang.arc.attachedcall". If the edge to the normal
112  /// destination block is a critical edge, split it.
113  std::pair<bool, bool> insertAfterInvokes(Function &F, DominatorTree *DT);
114
115  /// Insert a retainRV/claimRV call.
116  CallInst *insertRVCall(Instruction *InsertPt, CallBase *AnnotatedCall);
117
118  /// Insert a retainRV/claimRV call with colors.
119  CallInst *insertRVCallWithColors(
120      Instruction *InsertPt, CallBase *AnnotatedCall,
121      const DenseMap<BasicBlock *, ColorVector> &BlockColors);
122
123  /// See if an instruction is a bundled retainRV/claimRV call.
124  bool contains(const Instruction *I) const {
125    if (auto *CI = dyn_cast<CallInst>(I))
126      return RVCalls.count(CI);
127    return false;
128  }
129
130  /// Remove a retainRV/claimRV call entirely.
131  void eraseInst(CallInst *CI) {
132    auto It = RVCalls.find(CI);
133    if (It != RVCalls.end()) {
134      // Remove call to @llvm.objc.clang.arc.noop.use.
135      for (User *U : It->second->users())
136        if (auto *CI = dyn_cast<CallInst>(U))
137          if (CI->getIntrinsicID() == Intrinsic::objc_clang_arc_noop_use) {
138            CI->eraseFromParent();
139            break;
140          }
141
142      auto *NewCall = CallBase::removeOperandBundle(
143          It->second, LLVMContext::OB_clang_arc_attachedcall, It->second);
144      NewCall->copyMetadata(*It->second);
145      It->second->replaceAllUsesWith(NewCall);
146      It->second->eraseFromParent();
147      RVCalls.erase(It);
148    }
149    EraseInstruction(CI);
150  }
151
152private:
153  /// A map of inserted retainRV/claimRV calls to annotated calls/invokes.
154  DenseMap<CallInst *, CallBase *> RVCalls;
155
156  bool ContractPass;
157};
158
159} // end namespace objcarc
160} // end namespace llvm
161
162#endif
163