CbC/CbC_llvm: lib/Transforms/ObjCARC/ObjCARCOpts.cpp comparison

comparison lib/Transforms/ObjCARC/ObjCARCOpts.cpp @ 95:afa8332a0e37 LLVM3.8

LLVM 3.8

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Tue, 13 Oct 2015 17:48:58 +0900
parents	60c9769439b8
children	7d135dc70f03

comparison

equal deleted inserted replaced

-:f3e34b893a5f
+:afa8332a0e37
 ///
 //===----------------------------------------------------------------------===//
 #include "ObjCARC.h"
 #include "ARCRuntimeEntryPoints.h"
+#include "BlotMapVector.h"
 #include "DependencyAnalysis.h"
-#include "ObjCARCAliasAnalysis.h"
 #include "ProvenanceAnalysis.h"
+#include "PtrState.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/ObjCARCAliasAnalysis.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 using namespace llvm::objcarc;
 #define DEBUG_TYPE "objc-arc-opts"
-/// \defgroup MiscUtils Miscellaneous utilities that are not ARC specific.
-/// @{
-namespace {
-/// \brief An associative container with fast insertion-order (deterministic)
-/// iteration over its elements. Plus the special blot operation.
-template<class KeyT, class ValueT>
-class MapVector {
-/// Map keys to indices in Vector.
-typedef DenseMap<KeyT, size_t> MapTy;
-MapTy Map;
-typedef std::vector<std::pair<KeyT, ValueT> > VectorTy;
-/// Keys and values.
-VectorTy Vector;
-public:
-typedef typename VectorTy::iterator iterator;
-typedef typename VectorTy::const_iterator const_iterator;
-iterator begin() { return Vector.begin(); }
-iterator end() { return Vector.end(); }
-const_iterator begin() const { return Vector.begin(); }
-const_iterator end() const { return Vector.end(); }
-#ifdef XDEBUG
-~MapVector() {
-assert(Vector.size() >= Map.size()); // May differ due to blotting.
-for (typename MapTy::const_iterator I = Map.begin(), E = Map.end();
-I != E; ++I) {
-assert(I->second < Vector.size());
-assert(Vector[I->second].first == I->first);
-}
-for (typename VectorTy::const_iterator I = Vector.begin(),
-E = Vector.end(); I != E; ++I)
-assert(!I->first ||
-(Map.count(I->first) &&
-Map[I->first] == size_t(I - Vector.begin())));
-}
-#endif
-ValueT &operator[](const KeyT &Arg) {
-std::pair<typename MapTy::iterator, bool> Pair =
-Map.insert(std::make_pair(Arg, size_t(0)));
-if (Pair.second) {
-size_t Num = Vector.size();
-Pair.first->second = Num;
-Vector.push_back(std::make_pair(Arg, ValueT()));
-return Vector[Num].second;
-}
-return Vector[Pair.first->second].second;
-}
-std::pair<iterator, bool>
-insert(const std::pair<KeyT, ValueT> &InsertPair) {
-std::pair<typename MapTy::iterator, bool> Pair =
-Map.insert(std::make_pair(InsertPair.first, size_t(0)));
-if (Pair.second) {
-size_t Num = Vector.size();
-Pair.first->second = Num;
-Vector.push_back(InsertPair);
-return std::make_pair(Vector.begin() + Num, true);
-}
-return std::make_pair(Vector.begin() + Pair.first->second, false);
-}
-iterator find(const KeyT &Key) {
-typename MapTy::iterator It = Map.find(Key);
-if (It == Map.end()) return Vector.end();
-return Vector.begin() + It->second;
-}
-const_iterator find(const KeyT &Key) const {
-typename MapTy::const_iterator It = Map.find(Key);
-if (It == Map.end()) return Vector.end();
-return Vector.begin() + It->second;
-}
-/// This is similar to erase, but instead of removing the element from the
-/// vector, it just zeros out the key in the vector. This leaves iterators
-/// intact, but clients must be prepared for zeroed-out keys when iterating.
-void blot(const KeyT &Key) {
-typename MapTy::iterator It = Map.find(Key);
-if (It == Map.end()) return;
-Vector[It->second].first = KeyT();
-Map.erase(It);
-}
-void clear() {
-Map.clear();
-Vector.clear();
-}
-};
-}
-/// @}
-///
 /// \defgroup ARCUtilities Utility declarations/definitions specific to ARC.
 /// @{
-/// \brief This is similar to StripPointerCastsAndObjCCalls but it stops as soon
+/// \brief This is similar to GetRCIdentityRoot but it stops as soon
 /// as it finds a value with multiple uses.
 static const Value *FindSingleUseIdentifiedObject(const Value *Arg) {
 if (Arg->hasOneUse()) {
 if (const BitCastInst *BC = dyn_cast<BitCastInst>(Arg))
 return FindSingleUseIdentifiedObject(BC->getOperand(0));
 if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Arg))
 if (GEP->hasAllZeroIndices())
 return FindSingleUseIdentifiedObject(GEP->getPointerOperand());
-if (IsForwarding(GetBasicInstructionClass(Arg)))
+if (IsForwarding(GetBasicARCInstKind(Arg)))
 return FindSingleUseIdentifiedObject(
 cast<CallInst>(Arg)->getArgOperand(0));
 if (!IsObjCIdentifiedObject(Arg))
 return nullptr;
 return Arg;
 // If we found an identifiable object but it has multiple uses, but they are
 // trivial uses, we can still consider this to be a single-use value.
 if (IsObjCIdentifiedObject(Arg)) {
 for (const User *U : Arg->users())
-if (!U->use_empty() || StripPointerCastsAndObjCCalls(U) != Arg)
+if (!U->use_empty() || GetRCIdentityRoot(U) != Arg)
 return nullptr;
 return Arg;
 }
 }
 /// This is a wrapper around getUnderlyingObjCPtr along the lines of
 /// GetUnderlyingObjects except that it returns early when it sees the first
 /// alloca.
-static inline bool AreAnyUnderlyingObjectsAnAlloca(const Value *V) {
+static inline bool AreAnyUnderlyingObjectsAnAlloca(const Value *V,
+const DataLayout &DL) {
 SmallPtrSet<const Value *, 4> Visited;
 SmallVector<const Value *, 4> Worklist;
 Worklist.push_back(V);
 do {
 const Value *P = Worklist.pop_back_val();
-P = GetUnderlyingObjCPtr(P);
+P = GetUnderlyingObjCPtr(P, DL);
 if (isa<AllocaInst>(P))
 return true;
 if (!Visited.insert(P).second)
 Worklist.push_back(SI->getFalseValue());
 continue;
 }
 if (const PHINode *PN = dyn_cast<const PHINode>(P)) {
-for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
+for (Value *IncValue : PN->incoming_values())
-Worklist.push_back(PN->getIncomingValue(i));
+Worklist.push_back(IncValue);
 continue;
 }
 } while (!Worklist.empty());
 return false;
 STATISTIC(NumReleasesAfterOpt,
 "Number of releases after optimization");
 #endif
 namespace {
-/// \enum Sequence
-///
-/// \brief A sequence of states that a pointer may go through in which an
-/// objc_retain and objc_release are actually needed.
-enum Sequence {
-S_None,
-S_Retain,         ///< objc_retain(x).
-S_CanRelease,     ///< foo(x) -- x could possibly see a ref count decrement.
-S_Use,            ///< any use of x.
-S_Stop,           ///< like S_Release, but code motion is stopped.
-S_Release,        ///< objc_release(x).
-S_MovableRelease  ///< objc_release(x), !clang.imprecise_release.
-};
-raw_ostream &operator<<(raw_ostream &OS, const Sequence S)
-LLVM_ATTRIBUTE_UNUSED;
-raw_ostream &operator<<(raw_ostream &OS, const Sequence S) {
-switch (S) {
-case S_None:
-return OS << "S_None";
-case S_Retain:
-return OS << "S_Retain";
-case S_CanRelease:
-return OS << "S_CanRelease";
-case S_Use:
-return OS << "S_Use";
-case S_Release:
-return OS << "S_Release";
-case S_MovableRelease:
-return OS << "S_MovableRelease";
-case S_Stop:
-return OS << "S_Stop";
-}
-llvm_unreachable("Unknown sequence type.");
-}
-}
-static Sequence MergeSeqs(Sequence A, Sequence B, bool TopDown) {
-// The easy cases.
-if (A == B)
-return A;
-if (A == S_None || B == S_None)
-return S_None;
-if (A > B) std::swap(A, B);
-if (TopDown) {
-// Choose the side which is further along in the sequence.
-if ((A == S_Retain || A == S_CanRelease) &&
-(B == S_CanRelease || B == S_Use))
-return B;
-} else {
-// Choose the side which is further along in the sequence.
-if ((A == S_Use || A == S_CanRelease) &&
-(B == S_Use || B == S_Release || B == S_Stop || B == S_MovableRelease))
-return A;
-// If both sides are releases, choose the more conservative one.
-if (A == S_Stop && (B == S_Release || B == S_MovableRelease))
-return A;
-if (A == S_Release && B == S_MovableRelease)
-return A;
-}
-return S_None;
-}
-namespace {
-/// \brief Unidirectional information about either a
-/// retain-decrement-use-release sequence or release-use-decrement-retain
-/// reverse sequence.
-struct RRInfo {
-/// After an objc_retain, the reference count of the referenced
-/// object is known to be positive. Similarly, before an objc_release, the
-/// reference count of the referenced object is known to be positive. If
-/// there are retain-release pairs in code regions where the retain count
-/// is known to be positive, they can be eliminated, regardless of any side
-/// effects between them.
-///
-/// Also, a retain+release pair nested within another retain+release
-/// pair all on the known same pointer value can be eliminated, regardless
-/// of any intervening side effects.
-///
-/// KnownSafe is true when either of these conditions is satisfied.
-bool KnownSafe;
-/// True of the objc_release calls are all marked with the "tail" keyword.
-bool IsTailCallRelease;
-/// If the Calls are objc_release calls and they all have a
-/// clang.imprecise_release tag, this is the metadata tag.
-MDNode *ReleaseMetadata;
-/// For a top-down sequence, the set of objc_retains or
-/// objc_retainBlocks. For bottom-up, the set of objc_releases.
-SmallPtrSet<Instruction *, 2> Calls;
-/// The set of optimal insert positions for moving calls in the opposite
-/// sequence.
-SmallPtrSet<Instruction *, 2> ReverseInsertPts;
-/// If this is true, we cannot perform code motion but can still remove
-/// retain/release pairs.
-bool CFGHazardAfflicted;
-RRInfo() :
-KnownSafe(false), IsTailCallRelease(false), ReleaseMetadata(nullptr),
-CFGHazardAfflicted(false) {}
-void clear();
-/// Conservatively merge the two RRInfo. Returns true if a partial merge has
-/// occurred, false otherwise.
-bool Merge(const RRInfo &Other);
-};
-}
-void RRInfo::clear() {
-KnownSafe = false;
-IsTailCallRelease = false;
-ReleaseMetadata = nullptr;
-Calls.clear();
-ReverseInsertPts.clear();
-CFGHazardAfflicted = false;
-}
-bool RRInfo::Merge(const RRInfo &Other) {
-// Conservatively merge the ReleaseMetadata information.
-if (ReleaseMetadata != Other.ReleaseMetadata)
-ReleaseMetadata = nullptr;
-// Conservatively merge the boolean state.
-KnownSafe &= Other.KnownSafe;
-IsTailCallRelease &= Other.IsTailCallRelease;
-CFGHazardAfflicted |= Other.CFGHazardAfflicted;
-// Merge the call sets.
-Calls.insert(Other.Calls.begin(), Other.Calls.end());
-// Merge the insert point sets. If there are any differences,
-// that makes this a partial merge.
-bool Partial = ReverseInsertPts.size() != Other.ReverseInsertPts.size();
-for (Instruction *Inst : Other.ReverseInsertPts)
-Partial |= ReverseInsertPts.insert(Inst).second;
-return Partial;
-}
-namespace {
-/// \brief This class summarizes several per-pointer runtime properties which
-/// are propogated through the flow graph.
-class PtrState {
-/// True if the reference count is known to be incremented.
-bool KnownPositiveRefCount;
-/// True if we've seen an opportunity for partial RR elimination, such as
-/// pushing calls into a CFG triangle or into one side of a CFG diamond.
-bool Partial;
-/// The current position in the sequence.
-unsigned char Seq : 8;
-/// Unidirectional information about the current sequence.
-RRInfo RRI;
-public:
-PtrState() : KnownPositiveRefCount(false), Partial(false),
-Seq(S_None) {}
-bool IsKnownSafe() const {
-return RRI.KnownSafe;
-}
-void SetKnownSafe(const bool NewValue) {
-RRI.KnownSafe = NewValue;
-}
-bool IsTailCallRelease() const {
-return RRI.IsTailCallRelease;
-}
-void SetTailCallRelease(const bool NewValue) {
-RRI.IsTailCallRelease = NewValue;
-}
-bool IsTrackingImpreciseReleases() const {
-return RRI.ReleaseMetadata != nullptr;
-}
-const MDNode *GetReleaseMetadata() const {
-return RRI.ReleaseMetadata;
-}
-void SetReleaseMetadata(MDNode *NewValue) {
-RRI.ReleaseMetadata = NewValue;
-}
-bool IsCFGHazardAfflicted() const {
-return RRI.CFGHazardAfflicted;
-}
-void SetCFGHazardAfflicted(const bool NewValue) {
-RRI.CFGHazardAfflicted = NewValue;
-}
-void SetKnownPositiveRefCount() {
-DEBUG(dbgs() << "Setting Known Positive.\n");
-KnownPositiveRefCount = true;
-}
-void ClearKnownPositiveRefCount() {
-DEBUG(dbgs() << "Clearing Known Positive.\n");
-KnownPositiveRefCount = false;
-}
-bool HasKnownPositiveRefCount() const {
-return KnownPositiveRefCount;
-}
-void SetSeq(Sequence NewSeq) {
-DEBUG(dbgs() << "Old: " << Seq << "; New: " << NewSeq << "\n");
-Seq = NewSeq;
-}
-Sequence GetSeq() const {
-return static_cast<Sequence>(Seq);
-}
-void ClearSequenceProgress() {
-ResetSequenceProgress(S_None);
-}
-void ResetSequenceProgress(Sequence NewSeq) {
-DEBUG(dbgs() << "Resetting sequence progress.\n");
-SetSeq(NewSeq);
-Partial = false;
-RRI.clear();
-}
-void Merge(const PtrState &Other, bool TopDown);
-void InsertCall(Instruction *I) {
-RRI.Calls.insert(I);
-}
-void InsertReverseInsertPt(Instruction *I) {
-RRI.ReverseInsertPts.insert(I);
-}
-void ClearReverseInsertPts() {
-RRI.ReverseInsertPts.clear();
-}
-bool HasReverseInsertPts() const {
-return !RRI.ReverseInsertPts.empty();
-}
-const RRInfo &GetRRInfo() const {
-return RRI;
-}
-};
-}
-void
-PtrState::Merge(const PtrState &Other, bool TopDown) {
-Seq = MergeSeqs(GetSeq(), Other.GetSeq(), TopDown);
-KnownPositiveRefCount &= Other.KnownPositiveRefCount;
-// If we're not in a sequence (anymore), drop all associated state.
-if (Seq == S_None) {
-Partial = false;
-RRI.clear();
-} else if (Partial || Other.Partial) {
-// If we're doing a merge on a path that's previously seen a partial
-// merge, conservatively drop the sequence, to avoid doing partial
-// RR elimination. If the branch predicates for the two merge differ,
-// mixing them is unsafe.
-ClearSequenceProgress();
-} else {
-// Otherwise merge the other PtrState's RRInfo into our RRInfo. At this
-// point, we know that currently we are not partial. Stash whether or not
-// the merge operation caused us to undergo a partial merging of reverse
-// insertion points.
-Partial = RRI.Merge(Other.RRI);
-}
-}
-namespace {
 /// \brief Per-BasicBlock state.
 class BBState {
 /// The number of unique control paths from the entry which can reach this
 /// block.
 unsigned TopDownPathCount;
 /// The number of unique control paths to exits from this block.
 unsigned BottomUpPathCount;
-/// A type for PerPtrTopDown and PerPtrBottomUp.
-typedef MapVector<const Value *, PtrState> MapTy;
 /// The top-down traversal uses this to record information known about a
 /// pointer at the bottom of each block.
-MapTy PerPtrTopDown;
+BlotMapVector<const Value *, TopDownPtrState> PerPtrTopDown;
 /// The bottom-up traversal uses this to record information known about a
 /// pointer at the top of each block.
-MapTy PerPtrBottomUp;
+BlotMapVector<const Value *, BottomUpPtrState> PerPtrBottomUp;
 /// Effective predecessors of the current block ignoring ignorable edges and
 /// ignored backedges.
 SmallVector<BasicBlock *, 2> Preds;
 /// Effective successors of the current block ignoring ignorable edges and
 /// ignored backedges.
 SmallVector<BasicBlock *, 2> Succs;
 public:
 static const unsigned OverflowOccurredValue;
 BBState() : TopDownPathCount(0), BottomUpPathCount(0) { }
-typedef MapTy::iterator ptr_iterator;
+typedef decltype(PerPtrTopDown)::iterator top_down_ptr_iterator;
-typedef MapTy::const_iterator ptr_const_iterator;
+typedef decltype(PerPtrTopDown)::const_iterator const_top_down_ptr_iterator;
-ptr_iterator top_down_ptr_begin() { return PerPtrTopDown.begin(); }
+top_down_ptr_iterator top_down_ptr_begin() { return PerPtrTopDown.begin(); }
-ptr_iterator top_down_ptr_end() { return PerPtrTopDown.end(); }
+top_down_ptr_iterator top_down_ptr_end() { return PerPtrTopDown.end(); }
-ptr_const_iterator top_down_ptr_begin() const {
+const_top_down_ptr_iterator top_down_ptr_begin() const {
 return PerPtrTopDown.begin();
 }
-ptr_const_iterator top_down_ptr_end() const {
+const_top_down_ptr_iterator top_down_ptr_end() const {
 return PerPtrTopDown.end();
 }
+bool hasTopDownPtrs() const {
-ptr_iterator bottom_up_ptr_begin() { return PerPtrBottomUp.begin(); }
+return !PerPtrTopDown.empty();
-ptr_iterator bottom_up_ptr_end() { return PerPtrBottomUp.end(); }
+}
-ptr_const_iterator bottom_up_ptr_begin() const {
+typedef decltype(PerPtrBottomUp)::iterator bottom_up_ptr_iterator;
+typedef decltype(
+PerPtrBottomUp)::const_iterator const_bottom_up_ptr_iterator;
+bottom_up_ptr_iterator bottom_up_ptr_begin() {
 return PerPtrBottomUp.begin();
 }
-ptr_const_iterator bottom_up_ptr_end() const {
+bottom_up_ptr_iterator bottom_up_ptr_end() { return PerPtrBottomUp.end(); }
+const_bottom_up_ptr_iterator bottom_up_ptr_begin() const {
+return PerPtrBottomUp.begin();
+}
+const_bottom_up_ptr_iterator bottom_up_ptr_end() const {
 return PerPtrBottomUp.end();
+}
+bool hasBottomUpPtrs() const {
+return !PerPtrBottomUp.empty();
 }
 /// Mark this block as being an entry block, which has one path from the
 /// entry by definition.
 void SetAsEntry() { TopDownPathCount = 1; }
 void SetAsExit()  { BottomUpPathCount = 1; }
 /// Attempt to find the PtrState object describing the top down state for
 /// pointer Arg. Return a new initialized PtrState describing the top down
 /// state for Arg if we do not find one.
-PtrState &getPtrTopDownState(const Value *Arg) {
+TopDownPtrState &getPtrTopDownState(const Value *Arg) {
 return PerPtrTopDown[Arg];
 }
 /// Attempt to find the PtrState object describing the bottom up state for
 /// pointer Arg. Return a new initialized PtrState describing the bottom up
 /// state for Arg if we do not find one.
-PtrState &getPtrBottomUpState(const Value *Arg) {
+BottomUpPtrState &getPtrBottomUpState(const Value *Arg) {
 return PerPtrBottomUp[Arg];
 }
 /// Attempt to find the PtrState object describing the bottom up state for
 /// pointer Arg.
-ptr_iterator findPtrBottomUpState(const Value *Arg) {
+bottom_up_ptr_iterator findPtrBottomUpState(const Value *Arg) {
 return PerPtrBottomUp.find(Arg);
 }
 void clearBottomUpPointers() {
 PerPtrBottomUp.clear();
 };
 const unsigned BBState::OverflowOccurredValue = 0xffffffff;
 }
+namespace llvm {
+raw_ostream &operator<<(raw_ostream &OS,
+BBState &BBState) LLVM_ATTRIBUTE_UNUSED;
+}
 void BBState::InitFromPred(const BBState &Other) {
 PerPtrTopDown = Other.PerPtrTopDown;
 TopDownPathCount = Other.TopDownPathCount;
 }
 }
 // For each entry in the other set, if our set has an entry with the same key,
 // merge the entries. Otherwise, copy the entry and merge it with an empty
 // entry.
-for (ptr_const_iterator MI = Other.top_down_ptr_begin(),
+for (auto MI = Other.top_down_ptr_begin(), ME = Other.top_down_ptr_end();
-ME = Other.top_down_ptr_end(); MI != ME; ++MI) {
+MI != ME; ++MI) {
-std::pair<ptr_iterator, bool> Pair = PerPtrTopDown.insert(*MI);
+auto Pair = PerPtrTopDown.insert(*MI);
-Pair.first->second.Merge(Pair.second ? PtrState() : MI->second,
+Pair.first->second.Merge(Pair.second ? TopDownPtrState() : MI->second,
 /*TopDown=*/true);
 }
 // For each entry in our set, if the other set doesn't have an entry with the
 // same key, force it to merge with an empty entry.
-for (ptr_iterator MI = top_down_ptr_begin(),
+for (auto MI = top_down_ptr_begin(), ME = top_down_ptr_end(); MI != ME; ++MI)
-ME = top_down_ptr_end(); MI != ME; ++MI)
 if (Other.PerPtrTopDown.find(MI->first) == Other.PerPtrTopDown.end())
-MI->second.Merge(PtrState(), /*TopDown=*/true);
+MI->second.Merge(TopDownPtrState(), /*TopDown=*/true);
 }
 /// The bottom-up traversal uses this to merge information about successors to
 /// form the initial state for a new block.
 void BBState::MergeSucc(const BBState &Other) {
 }
 // For each entry in the other set, if our set has an entry with the
 // same key, merge the entries. Otherwise, copy the entry and merge
 // it with an empty entry.
-for (ptr_const_iterator MI = Other.bottom_up_ptr_begin(),
+for (auto MI = Other.bottom_up_ptr_begin(), ME = Other.bottom_up_ptr_end();
-ME = Other.bottom_up_ptr_end(); MI != ME; ++MI) {
+MI != ME; ++MI) {
-std::pair<ptr_iterator, bool> Pair = PerPtrBottomUp.insert(*MI);
+auto Pair = PerPtrBottomUp.insert(*MI);
-Pair.first->second.Merge(Pair.second ? PtrState() : MI->second,
+Pair.first->second.Merge(Pair.second ? BottomUpPtrState() : MI->second,
 /*TopDown=*/false);
 }
 // For each entry in our set, if the other set doesn't have an entry
 // with the same key, force it to merge with an empty entry.
-for (ptr_iterator MI = bottom_up_ptr_begin(),
+for (auto MI = bottom_up_ptr_begin(), ME = bottom_up_ptr_end(); MI != ME;
-ME = bottom_up_ptr_end(); MI != ME; ++MI)
+++MI)
 if (Other.PerPtrBottomUp.find(MI->first) == Other.PerPtrBottomUp.end())
-MI->second.Merge(PtrState(), /*TopDown=*/false);
+MI->second.Merge(BottomUpPtrState(), /*TopDown=*/false);
 }
-// Only enable ARC Annotations if we are building a debug version of
+raw_ostream &llvm::operator<<(raw_ostream &OS, BBState &BBInfo) {
-// libObjCARCOpts.
+// Dump the pointers we are tracking.
-#ifndef NDEBUG
+OS << "    TopDown State:\n";
-#define ARC_ANNOTATIONS
+if (!BBInfo.hasTopDownPtrs()) {
-#endif
+DEBUG(llvm::dbgs() << "        NONE!\n");
+} else {
-// Define some macros along the lines of DEBUG and some helper functions to make
+for (auto I = BBInfo.top_down_ptr_begin(), E = BBInfo.top_down_ptr_end();
-// it cleaner to create annotations in the source code and to no-op when not
+I != E; ++I) {
-// building in debug mode.
+const PtrState &P = I->second;
-#ifdef ARC_ANNOTATIONS
+OS << "        Ptr: " << *I->first
+<< "\n            KnownSafe:        " << (P.IsKnownSafe()?"true":"false")
-#include "llvm/Support/CommandLine.h"
+<< "\n            ImpreciseRelease: "
+<< (P.IsTrackingImpreciseReleases()?"true":"false") << "\n"
-/// Enable/disable ARC sequence annotations.
+<< "            HasCFGHazards:    "
-static cl::opt<bool>
+<< (P.IsCFGHazardAfflicted()?"true":"false") << "\n"
-EnableARCAnnotations("enable-objc-arc-annotations", cl::init(false),
+<< "            KnownPositive:    "
-cl::desc("Enable emission of arc data flow analysis "
+<< (P.HasKnownPositiveRefCount()?"true":"false") << "\n"
-"annotations"));
+<< "            Seq:              "
-static cl::opt<bool>
+<< P.GetSeq() << "\n";
-DisableCheckForCFGHazards("disable-objc-arc-checkforcfghazards", cl::init(false),
+}
-cl::desc("Disable check for cfg hazards when "
+}
-"annotating"));
-static cl::opt<std::string>
+OS << "    BottomUp State:\n";
-ARCAnnotationTargetIdentifier("objc-arc-annotation-target-identifier",
+if (!BBInfo.hasBottomUpPtrs()) {
-cl::init(""),
+DEBUG(llvm::dbgs() << "        NONE!\n");
-cl::desc("filter out all data flow annotations "
+} else {
-"but those that apply to the given "
+for (auto I = BBInfo.bottom_up_ptr_begin(), E = BBInfo.bottom_up_ptr_end();
-"target llvm identifier."));
+I != E; ++I) {
+const PtrState &P = I->second;
-/// This function appends a unique ARCAnnotationProvenanceSourceMDKind id to an
+OS << "        Ptr: " << *I->first
-/// instruction so that we can track backwards when post processing via the llvm
+<< "\n            KnownSafe:        " << (P.IsKnownSafe()?"true":"false")
-/// arc annotation processor tool. If the function is an
+<< "\n            ImpreciseRelease: "
-static MDString *AppendMDNodeToSourcePtr(unsigned NodeId,
+<< (P.IsTrackingImpreciseReleases()?"true":"false") << "\n"
-Value *Ptr) {
+<< "            HasCFGHazards:    "
-MDString *Hash = nullptr;
+<< (P.IsCFGHazardAfflicted()?"true":"false") << "\n"
+<< "            KnownPositive:    "
-// If pointer is a result of an instruction and it does not have a source
+<< (P.HasKnownPositiveRefCount()?"true":"false") << "\n"
-// MDNode it, attach a new MDNode onto it. If pointer is a result of
+<< "            Seq:              "
-// an instruction and does have a source MDNode attached to it, return a
+<< P.GetSeq() << "\n";
-// reference to said Node. Otherwise just return 0.
+}
-if (Instruction *Inst = dyn_cast<Instruction>(Ptr)) {
+}
-MDNode *Node;
-if (!(Node = Inst->getMetadata(NodeId))) {
+return OS;
-// We do not have any node. Generate and attatch the hash MDString to the
+}
-// instruction.
-// We just use an MDString to ensure that this metadata gets written out
-// of line at the module level and to provide a very simple format
-// encoding the information herein. Both of these makes it simpler to
-// parse the annotations by a simple external program.
-std::string Str;
-raw_string_ostream os(Str);
-os << "(" << Inst->getParent()->getParent()->getName() << ",%"
-<< Inst->getName() << ")";
-Hash = MDString::get(Inst->getContext(), os.str());
-Inst->setMetadata(NodeId, MDNode::get(Inst->getContext(),Hash));
-} else {
-// We have a node. Grab its hash and return it.
-assert(Node->getNumOperands() == 1 &&
-"An ARCAnnotationProvenanceSourceMDKind can only have 1 operand.");
-Hash = cast<MDString>(Node->getOperand(0));
-}
-} else if (Argument *Arg = dyn_cast<Argument>(Ptr)) {
-std::string str;
-raw_string_ostream os(str);
-os << "(" << Arg->getParent()->getName() << ",%" << Arg->getName()
-<< ")";
-Hash = MDString::get(Arg->getContext(), os.str());
-}
-return Hash;
-}
-static std::string SequenceToString(Sequence A) {
-std::string str;
-raw_string_ostream os(str);
-os << A;
-return os.str();
-}
-/// Helper function to change a Sequence into a String object using our overload
-/// for raw_ostream so we only have printing code in one location.
-static MDString *SequenceToMDString(LLVMContext &Context,
-Sequence A) {
-return MDString::get(Context, SequenceToString(A));
-}
-/// A simple function to generate a MDNode which describes the change in state
-/// for Value *Ptr caused by Instruction *Inst.
-static void AppendMDNodeToInstForPtr(unsigned NodeId,
-Instruction *Inst,
-Value *Ptr,
-MDString *PtrSourceMDNodeID,
-Sequence OldSeq,
-Sequence NewSeq) {
-MDNode *Node = nullptr;
-Metadata *tmp[3] = {PtrSourceMDNodeID,
-SequenceToMDString(Inst->getContext(), OldSeq),
-SequenceToMDString(Inst->getContext(), NewSeq)};
-Node = MDNode::get(Inst->getContext(), tmp);
-Inst->setMetadata(NodeId, Node);
-}
-/// Add to the beginning of the basic block llvm.ptr.annotations which show the
-/// state of a pointer at the entrance to a basic block.
-static void GenerateARCBBEntranceAnnotation(const char *Name, BasicBlock *BB,
-Value *Ptr, Sequence Seq) {
-// If we have a target identifier, make sure that we match it before
-// continuing.
-if(!ARCAnnotationTargetIdentifier.empty() &&
-!Ptr->getName().equals(ARCAnnotationTargetIdentifier))
-return;
-Module *M = BB->getParent()->getParent();
-LLVMContext &C = M->getContext();
-Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
-Type *I8XX = PointerType::getUnqual(I8X);
-Type *Params[] = {I8XX, I8XX};
-FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), Params,
-/*isVarArg=*/false);
-Constant *Callee = M->getOrInsertFunction(Name, FTy);
-IRBuilder<> Builder(BB, BB->getFirstInsertionPt());
-Value *PtrName;
-StringRef Tmp = Ptr->getName();
-if (nullptr == (PtrName = M->getGlobalVariable(Tmp, true))) {
-Value *ActualPtrName = Builder.CreateGlobalStringPtr(Tmp,
-Tmp + "_STR");
-PtrName = new GlobalVariable(*M, I8X, true, GlobalVariable::InternalLinkage,
-cast<Constant>(ActualPtrName), Tmp);
-}
-Value *S;
-std::string SeqStr = SequenceToString(Seq);
-if (nullptr == (S = M->getGlobalVariable(SeqStr, true))) {
-Value *ActualPtrName = Builder.CreateGlobalStringPtr(SeqStr,
-SeqStr + "_STR");
-S = new GlobalVariable(*M, I8X, true, GlobalVariable::InternalLinkage,
-cast<Constant>(ActualPtrName), SeqStr);
-}
-Builder.CreateCall2(Callee, PtrName, S);
-}
-/// Add to the end of the basic block llvm.ptr.annotations which show the state
-/// of the pointer at the bottom of the basic block.
-static void GenerateARCBBTerminatorAnnotation(const char *Name, BasicBlock *BB,
-Value *Ptr, Sequence Seq) {
-// If we have a target identifier, make sure that we match it before emitting
-// an annotation.
-if(!ARCAnnotationTargetIdentifier.empty() &&
-!Ptr->getName().equals(ARCAnnotationTargetIdentifier))
-return;
-Module *M = BB->getParent()->getParent();
-LLVMContext &C = M->getContext();
-Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
-Type *I8XX = PointerType::getUnqual(I8X);
-Type *Params[] = {I8XX, I8XX};
-FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), Params,
-/*isVarArg=*/false);
-Constant *Callee = M->getOrInsertFunction(Name, FTy);
-IRBuilder<> Builder(BB, std::prev(BB->end()));
-Value *PtrName;
-StringRef Tmp = Ptr->getName();
-if (nullptr == (PtrName = M->getGlobalVariable(Tmp, true))) {
-Value *ActualPtrName = Builder.CreateGlobalStringPtr(Tmp,
-Tmp + "_STR");
-PtrName = new GlobalVariable(*M, I8X, true, GlobalVariable::InternalLinkage,
-cast<Constant>(ActualPtrName), Tmp);
-}
-Value *S;
-std::string SeqStr = SequenceToString(Seq);
-if (nullptr == (S = M->getGlobalVariable(SeqStr, true))) {
-Value *ActualPtrName = Builder.CreateGlobalStringPtr(SeqStr,
-SeqStr + "_STR");
-S = new GlobalVariable(*M, I8X, true, GlobalVariable::InternalLinkage,
-cast<Constant>(ActualPtrName), SeqStr);
-}
-Builder.CreateCall2(Callee, PtrName, S);
-}
-/// Adds a source annotation to pointer and a state change annotation to Inst
-/// referencing the source annotation and the old/new state of pointer.
-static void GenerateARCAnnotation(unsigned InstMDId,
-unsigned PtrMDId,
-Instruction *Inst,
-Value *Ptr,
-Sequence OldSeq,
-Sequence NewSeq) {
-if (EnableARCAnnotations) {
-// If we have a target identifier, make sure that we match it before
-// emitting an annotation.
-if(!ARCAnnotationTargetIdentifier.empty() &&
-!Ptr->getName().equals(ARCAnnotationTargetIdentifier))
-return;
-// First generate the source annotation on our pointer. This will return an
-// MDString* if Ptr actually comes from an instruction implying we can put
-// in a source annotation. If AppendMDNodeToSourcePtr returns 0 (i.e. NULL),
-// then we know that our pointer is from an Argument so we put a reference
-// to the argument number.
-//
-// The point of this is to make it easy for the
-// llvm-arc-annotation-processor tool to cross reference where the source
-// pointer is in the LLVM IR since the LLVM IR parser does not submit such
-// information via debug info for backends to use (since why would anyone
-// need such a thing from LLVM IR besides in non-standard cases
-// [i.e. this]).
-MDString *SourcePtrMDNode =
-AppendMDNodeToSourcePtr(PtrMDId, Ptr);
-AppendMDNodeToInstForPtr(InstMDId, Inst, Ptr, SourcePtrMDNode, OldSeq,
-NewSeq);
-}
-}
-// The actual interface for accessing the above functionality is defined via
-// some simple macros which are defined below. We do this so that the user does
-// not need to pass in what metadata id is needed resulting in cleaner code and
-// additionally since it provides an easy way to conditionally no-op all
-// annotation support in a non-debug build.
-/// Use this macro to annotate a sequence state change when processing
-/// instructions bottom up,
-#define ANNOTATE_BOTTOMUP(inst, ptr, old, new)                          \
-GenerateARCAnnotation(ARCAnnotationBottomUpMDKind,                    \
-ARCAnnotationProvenanceSourceMDKind, (inst),    \
-const_cast<Value*>(ptr), (old), (new))
-/// Use this macro to annotate a sequence state change when processing
-/// instructions top down.
-#define ANNOTATE_TOPDOWN(inst, ptr, old, new)                           \
-GenerateARCAnnotation(ARCAnnotationTopDownMDKind,                     \
-ARCAnnotationProvenanceSourceMDKind, (inst),    \
-const_cast<Value*>(ptr), (old), (new))
-#define ANNOTATE_BB(_states, _bb, _name, _type, _direction)                   \
-do {                                                                        \
-if (EnableARCAnnotations) {                                               \
-for(BBState::ptr_const_iterator I = (_states)._direction##_ptr_begin(), \
-E = (_states)._direction##_ptr_end(); I != E; ++I) {                \
-Value *Ptr = const_cast<Value*>(I->first);                            \
-Sequence Seq = I->second.GetSeq();                                    \
-GenerateARCBB ## _type ## Annotation(_name, (_bb), Ptr, Seq);         \
-}                                                                       \
-}                                                                         \
-} while (0)
-#define ANNOTATE_BOTTOMUP_BBSTART(_states, _basicblock)                       \
-ANNOTATE_BB(_states, _basicblock, "llvm.arc.annotation.bottomup.bbstart", \
-Entrance, bottom_up)
-#define ANNOTATE_BOTTOMUP_BBEND(_states, _basicblock)                         \
-ANNOTATE_BB(_states, _basicblock, "llvm.arc.annotation.bottomup.bbend",   \
-Terminator, bottom_up)
-#define ANNOTATE_TOPDOWN_BBSTART(_states, _basicblock)                        \
-ANNOTATE_BB(_states, _basicblock, "llvm.arc.annotation.topdown.bbstart",  \
-Entrance, top_down)
-#define ANNOTATE_TOPDOWN_BBEND(_states, _basicblock)                          \
-ANNOTATE_BB(_states, _basicblock, "llvm.arc.annotation.topdown.bbend",    \
-Terminator, top_down)
-#else // !ARC_ANNOTATION
-// If annotations are off, noop.
-#define ANNOTATE_BOTTOMUP(inst, ptr, old, new)
-#define ANNOTATE_TOPDOWN(inst, ptr, old, new)
-#define ANNOTATE_BOTTOMUP_BBSTART(states, basicblock)
-#define ANNOTATE_BOTTOMUP_BBEND(states, basicblock)
-#define ANNOTATE_TOPDOWN_BBSTART(states, basicblock)
-#define ANNOTATE_TOPDOWN_BBEND(states, basicblock)
-#endif // !ARC_ANNOTATION
 namespace {
 /// \brief The main ARC optimization pass.
 class ObjCARCOpt : public FunctionPass {
 bool Changed;
 ProvenanceAnalysis PA;
+/// A cache of references to runtime entry point constants.
 ARCRuntimeEntryPoints EP;
+/// A cache of MDKinds that can be passed into other functions to propagate
+/// MDKind identifiers.
+ARCMDKindCache MDKindCache;
 // This is used to track if a pointer is stored into an alloca.
 DenseSet<const Value *> MultiOwnersSet;
 /// A flag indicating whether this optimization pass should run.
 bool Run;
-/// Flags which determine whether each of the interesting runtine functions
+/// Flags which determine whether each of the interesting runtime functions
 /// is in fact used in the current function.
 unsigned UsedInThisFunction;
-/// The Metadata Kind for clang.imprecise_release metadata.
-unsigned ImpreciseReleaseMDKind;
-/// The Metadata Kind for clang.arc.copy_on_escape metadata.
-unsigned CopyOnEscapeMDKind;
-/// The Metadata Kind for clang.arc.no_objc_arc_exceptions metadata.
-unsigned NoObjCARCExceptionsMDKind;
-#ifdef ARC_ANNOTATIONS
-/// The Metadata Kind for llvm.arc.annotation.bottomup metadata.
-unsigned ARCAnnotationBottomUpMDKind;
-/// The Metadata Kind for llvm.arc.annotation.topdown metadata.
-unsigned ARCAnnotationTopDownMDKind;
-/// The Metadata Kind for llvm.arc.annotation.provenancesource metadata.
-unsigned ARCAnnotationProvenanceSourceMDKind;
-#endif // ARC_ANNOATIONS
 bool OptimizeRetainRVCall(Function &F, Instruction *RetainRV);
 void OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
-InstructionClass &Class);
+ARCInstKind &Class);
 void OptimizeIndividualCalls(Function &F);
 void CheckForCFGHazards(const BasicBlock *BB,
 DenseMap<const BasicBlock *, BBState> &BBStates,
 BBState &MyStates) const;
-bool VisitInstructionBottomUp(Instruction *Inst,
+bool VisitInstructionBottomUp(Instruction *Inst, BasicBlock *BB,
-BasicBlock *BB,
+BlotMapVector<Value *, RRInfo> &Retains,
-MapVector<Value *, RRInfo> &Retains,
 BBState &MyStates);
 bool VisitBottomUp(BasicBlock *BB,
 DenseMap<const BasicBlock *, BBState> &BBStates,
-MapVector<Value *, RRInfo> &Retains);
+BlotMapVector<Value *, RRInfo> &Retains);
 bool VisitInstructionTopDown(Instruction *Inst,
 DenseMap<Value *, RRInfo> &Releases,
 BBState &MyStates);
 bool VisitTopDown(BasicBlock *BB,
 DenseMap<const BasicBlock *, BBState> &BBStates,
 DenseMap<Value *, RRInfo> &Releases);
-bool Visit(Function &F,
+bool Visit(Function &F, DenseMap<const BasicBlock *, BBState> &BBStates,
-DenseMap<const BasicBlock *, BBState> &BBStates,
+BlotMapVector<Value *, RRInfo> &Retains,
-MapVector<Value *, RRInfo> &Retains,
 DenseMap<Value *, RRInfo> &Releases);
 void MoveCalls(Value *Arg, RRInfo &RetainsToMove, RRInfo &ReleasesToMove,
-MapVector<Value *, RRInfo> &Retains,
+BlotMapVector<Value *, RRInfo> &Retains,
 DenseMap<Value *, RRInfo> &Releases,
-SmallVectorImpl<Instruction *> &DeadInsts,
+SmallVectorImpl<Instruction *> &DeadInsts, Module *M);
-Module *M);
+bool
-bool ConnectTDBUTraversals(DenseMap<const BasicBlock *, BBState> &BBStates,
+PairUpRetainsAndReleases(DenseMap<const BasicBlock *, BBState> &BBStates,
-MapVector<Value *, RRInfo> &Retains,
+BlotMapVector<Value *, RRInfo> &Retains,
-DenseMap<Value *, RRInfo> &Releases,
+DenseMap<Value *, RRInfo> &Releases, Module *M,
-Module *M,
+SmallVectorImpl<Instruction *> &NewRetains,
-SmallVectorImpl<Instruction *> &NewRetains,
+SmallVectorImpl<Instruction *> &NewReleases,
-SmallVectorImpl<Instruction *> &NewReleases,
+SmallVectorImpl<Instruction *> &DeadInsts,
-SmallVectorImpl<Instruction *> &DeadInsts,
+RRInfo &RetainsToMove, RRInfo &ReleasesToMove,
-RRInfo &RetainsToMove,
+Value *Arg, bool KnownSafe,
-RRInfo &ReleasesToMove,
+bool &AnyPairsCompletelyEliminated);
-Value *Arg,
-bool KnownSafe,
-bool &AnyPairsCompletelyEliminated);
 bool PerformCodePlacement(DenseMap<const BasicBlock *, BBState> &BBStates,
-MapVector<Value *, RRInfo> &Retains,
+BlotMapVector<Value *, RRInfo> &Retains,
-DenseMap<Value *, RRInfo> &Releases,
+DenseMap<Value *, RRInfo> &Releases, Module *M);
-Module *M);
 void OptimizeWeakCalls(Function &F);
 bool OptimizeSequences(Function &F);
 }
 char ObjCARCOpt::ID = 0;
 INITIALIZE_PASS_BEGIN(ObjCARCOpt,
 "objc-arc", "ObjC ARC optimization", false, false)
-INITIALIZE_PASS_DEPENDENCY(ObjCARCAliasAnalysis)
+INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
 INITIALIZE_PASS_END(ObjCARCOpt,
 "objc-arc", "ObjC ARC optimization", false, false)
 Pass *llvm::createObjCARCOptPass() {
 return new ObjCARCOpt();
 }
 void ObjCARCOpt::getAnalysisUsage(AnalysisUsage &AU) const {
-AU.addRequired<ObjCARCAliasAnalysis>();
+AU.addRequired<ObjCARCAAWrapperPass>();
-AU.addRequired<AliasAnalysis>();
+AU.addRequired<AAResultsWrapperPass>();
 // ARC optimization doesn't currently split critical edges.
 AU.setPreservesCFG();
 }
 /// Turn objc_retainAutoreleasedReturnValue into objc_retain if the operand is
 /// not a return value.  Or, if it can be paired with an
 /// objc_autoreleaseReturnValue, delete the pair and return true.
 bool
 ObjCARCOpt::OptimizeRetainRVCall(Function &F, Instruction *RetainRV) {
 // Check for the argument being from an immediately preceding call or invoke.
-const Value *Arg = GetObjCArg(RetainRV);
+const Value *Arg = GetArgRCIdentityRoot(RetainRV);
 ImmutableCallSite CS(Arg);
 if (const Instruction *Call = CS.getInstruction()) {
 if (Call->getParent() == RetainRV->getParent()) {
 BasicBlock::const_iterator I = Call;
 ++I;
 // Check for being preceded by an objc_autoreleaseReturnValue on the same
 // pointer. In this case, we can delete the pair.
 BasicBlock::iterator I = RetainRV, Begin = RetainRV->getParent()->begin();
 if (I != Begin) {
 do --I; while (I != Begin && IsNoopInstruction(I));
-if (GetBasicInstructionClass(I) == IC_AutoreleaseRV &&
+if (GetBasicARCInstKind(I) == ARCInstKind::AutoreleaseRV &&
-GetObjCArg(I) == Arg) {
+GetArgRCIdentityRoot(I) == Arg) {
 Changed = true;
 ++NumPeeps;
 DEBUG(dbgs() << "Erasing autoreleaseRV,retainRV pair: " << *I << "\n"
 << "Erasing " << *RetainRV << "\n");
 DEBUG(dbgs() << "Transforming objc_retainAutoreleasedReturnValue => "
 "objc_retain since the operand is not a return value.\n"
 "Old = " << *RetainRV << "\n");
-Constant *NewDecl = EP.get(ARCRuntimeEntryPoints::EPT_Retain);
+Constant *NewDecl = EP.get(ARCRuntimeEntryPointKind::Retain);
 cast<CallInst>(RetainRV)->setCalledFunction(NewDecl);
 DEBUG(dbgs() << "New = " << *RetainRV << "\n");
 return false;
 }
 /// Turn objc_autoreleaseReturnValue into objc_autorelease if the result is not
 /// used as a return value.
-void
+void ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F,
-ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
+Instruction *AutoreleaseRV,
-InstructionClass &Class) {
+ARCInstKind &Class) {
 // Check for a return of the pointer value.
-const Value *Ptr = GetObjCArg(AutoreleaseRV);
+const Value *Ptr = GetArgRCIdentityRoot(AutoreleaseRV);
 SmallVector<const Value *, 2> Users;
 Users.push_back(Ptr);
 do {
 Ptr = Users.pop_back_val();
 for (const User *U : Ptr->users()) {
-if (isa<ReturnInst>(U) || GetBasicInstructionClass(U) == IC_RetainRV)
+if (isa<ReturnInst>(U) || GetBasicARCInstKind(U) == ARCInstKind::RetainRV)
 return;
 if (isa<BitCastInst>(U))
 Users.push_back(U);
 }
 } while (!Users.empty());
 "objc_autorelease since its operand is not used as a return "
 "value.\n"
 "Old = " << *AutoreleaseRV << "\n");
 CallInst *AutoreleaseRVCI = cast<CallInst>(AutoreleaseRV);
-Constant *NewDecl = EP.get(ARCRuntimeEntryPoints::EPT_Autorelease);
+Constant *NewDecl = EP.get(ARCRuntimeEntryPointKind::Autorelease);
 AutoreleaseRVCI->setCalledFunction(NewDecl);
 AutoreleaseRVCI->setTailCall(false); // Never tail call objc_autorelease.
-Class = IC_Autorelease;
+Class = ARCInstKind::Autorelease;
 DEBUG(dbgs() << "New: " << *AutoreleaseRV << "\n");
 }
 // Visit all objc_* calls in F.
 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
 Instruction *Inst = &*I++;
-InstructionClass Class = GetBasicInstructionClass(Inst);
+ARCInstKind Class = GetBasicARCInstKind(Inst);
 DEBUG(dbgs() << "Visiting: Class: " << Class << "; " << *Inst << "\n");
 switch (Class) {
 default: break;
 // which return their argument.
 //
 // There are gray areas here, as the ability to cast reference-counted
 // pointers to raw void* and back allows code to break ARC assumptions,
 // however these are currently considered to be unimportant.
-case IC_NoopCast:
+case ARCInstKind::NoopCast:
 Changed = true;
 ++NumNoops;
 DEBUG(dbgs() << "Erasing no-op cast: " << *Inst << "\n");
 EraseInstruction(Inst);
 continue;
 // If the pointer-to-weak-pointer is null, it's undefined behavior.
-case IC_StoreWeak:
+case ARCInstKind::StoreWeak:
-case IC_LoadWeak:
+case ARCInstKind::LoadWeak:
-case IC_LoadWeakRetained:
+case ARCInstKind::LoadWeakRetained:
-case IC_InitWeak:
+case ARCInstKind::InitWeak:
-case IC_DestroyWeak: {
+case ARCInstKind::DestroyWeak: {
 CallInst *CI = cast<CallInst>(Inst);
 if (IsNullOrUndef(CI->getArgOperand(0))) {
 Changed = true;
 Type *Ty = CI->getArgOperand(0)->getType();
 new StoreInst(UndefValue::get(cast<PointerType>(Ty)->getElementType()),
 CI->eraseFromParent();
 continue;
 }
 break;
 }
-case IC_CopyWeak:
+case ARCInstKind::CopyWeak:
-case IC_MoveWeak: {
+case ARCInstKind::MoveWeak: {
 CallInst *CI = cast<CallInst>(Inst);
 if (IsNullOrUndef(CI->getArgOperand(0)) ||
 IsNullOrUndef(CI->getArgOperand(1))) {
 Changed = true;
 Type *Ty = CI->getArgOperand(0)->getType();
 CI->eraseFromParent();
 continue;
 }
 break;
 }
-case IC_RetainRV:
+case ARCInstKind::RetainRV:
 if (OptimizeRetainRVCall(F, Inst))
 continue;
 break;
-case IC_AutoreleaseRV:
+case ARCInstKind::AutoreleaseRV:
 OptimizeAutoreleaseRVCall(F, Inst, Class);
 break;
 }
 // objc_autorelease(x) -> objc_release(x) if x is otherwise unused.
 ++NumAutoreleases;
 // Create the declaration lazily.
 LLVMContext &C = Inst->getContext();
-Constant *Decl = EP.get(ARCRuntimeEntryPoints::EPT_Release);
+Constant *Decl = EP.get(ARCRuntimeEntryPointKind::Release);
 CallInst *NewCall = CallInst::Create(Decl, Call->getArgOperand(0), "",
 Call);
-NewCall->setMetadata(ImpreciseReleaseMDKind, MDNode::get(C, None));
+NewCall->setMetadata(MDKindCache.get(ARCMDKindID::ImpreciseRelease),
+MDNode::get(C, None));
 DEBUG(dbgs() << "Replacing autorelease{,RV}(x) with objc_release(x) "
 "since x is otherwise unused.\nOld: " << *Call << "\nNew: "
 << *NewCall << "\n");
 EraseInstruction(Call);
 Inst = NewCall;
-Class = IC_Release;
+Class = ARCInstKind::Release;
 }
 }
 // For functions which can never be passed stack arguments, add
 // a tail keyword.
 << "\n");
 cast<CallInst>(Inst)->setDoesNotThrow();
 }
 if (!IsNoopOnNull(Class)) {
-UsedInThisFunction |= 1 << Class;
+UsedInThisFunction |= 1 << unsigned(Class);
 continue;
 }
-const Value *Arg = GetObjCArg(Inst);
+const Value *Arg = GetArgRCIdentityRoot(Inst);
 // ARC calls with null are no-ops. Delete them.
 if (IsNullOrUndef(Arg)) {
 Changed = true;
 ++NumNoops;
 continue;
 }
 // Keep track of which of retain, release, autorelease, and retain_block
 // are actually present in this function.
-UsedInThisFunction |= 1 << Class;
+UsedInThisFunction |= 1 << unsigned(Class);
 // If Arg is a PHI, and one or more incoming values to the
 // PHI are null, and the call is control-equivalent to the PHI, and there
 // are no relevant side effects between the PHI and the call, the call
 // could be pushed up to just those paths with non-null incoming values.
 // critical edges.
 bool HasNull = false;
 bool HasCriticalEdges = false;
 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
 Value *Incoming =
-StripPointerCastsAndObjCCalls(PN->getIncomingValue(i));
+GetRCIdentityRoot(PN->getIncomingValue(i));
 if (IsNullOrUndef(Incoming))
 HasNull = true;
 else if (cast<TerminatorInst>(PN->getIncomingBlock(i)->back())
 .getNumSuccessors() != 1) {
 HasCriticalEdges = true;
 SmallPtrSet<const BasicBlock *, 4> Visited;
 // Check that there is nothing that cares about the reference
 // count between the call and the phi.
 switch (Class) {
-case IC_Retain:
+case ARCInstKind::Retain:
-case IC_RetainBlock:
+case ARCInstKind::RetainBlock:
 // These can always be moved up.
 break;
-case IC_Release:
+case ARCInstKind::Release:
 // These can't be moved across things that care about the retain
 // count.
 FindDependencies(NeedsPositiveRetainCount, Arg,
 Inst->getParent(), Inst,
 DependingInstructions, Visited, PA);
 break;
-case IC_Autorelease:
+case ARCInstKind::Autorelease:
 // These can't be moved across autorelease pool scope boundaries.
 FindDependencies(AutoreleasePoolBoundary, Arg,
 Inst->getParent(), Inst,
 DependingInstructions, Visited, PA);
 break;
-case IC_RetainRV:
+case ARCInstKind::RetainRV:
-case IC_AutoreleaseRV:
+case ARCInstKind::AutoreleaseRV:
 // Don't move these; the RV optimization depends on the autoreleaseRV
 // being tail called, and the retainRV being immediately after a call
 // (which might still happen if we get lucky with codegen layout, but
 // it's not worth taking the chance).
 continue;
 // Clone the call into each predecessor that has a non-null value.
 CallInst *CInst = cast<CallInst>(Inst);
 Type *ParamTy = CInst->getArgOperand(0)->getType();
 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
 Value *Incoming =
-StripPointerCastsAndObjCCalls(PN->getIncomingValue(i));
+GetRCIdentityRoot(PN->getIncomingValue(i));
 if (!IsNullOrUndef(Incoming)) {
 CallInst *Clone = cast<CallInst>(CInst->clone());
 Value *Op = PN->getIncomingValue(i);
 Instruction *InsertPos = &PN->getIncomingBlock(i)->back();
 if (Op->getType() != ParamTy)
 /// If we have a top down pointer in the S_Use state, make sure that there are
 /// no CFG hazards by checking the states of various bottom up pointers.
 static void CheckForUseCFGHazard(const Sequence SuccSSeq,
 const bool SuccSRRIKnownSafe,
-PtrState &S,
+TopDownPtrState &S,
 bool &SomeSuccHasSame,
 bool &AllSuccsHaveSame,
 bool &NotAllSeqEqualButKnownSafe,
 bool &ShouldContinue) {
 switch (SuccSSeq) {
 /// If we have a Top Down pointer in the S_CanRelease state, make sure that
 /// there are no CFG hazards by checking the states of various bottom up
 /// pointers.
 static void CheckForCanReleaseCFGHazard(const Sequence SuccSSeq,
 const bool SuccSRRIKnownSafe,
-PtrState &S,
+TopDownPtrState &S,
 bool &SomeSuccHasSame,
 bool &AllSuccsHaveSame,
 bool &NotAllSeqEqualButKnownSafe) {
 switch (SuccSSeq) {
 case S_CanRelease:
 ObjCARCOpt::CheckForCFGHazards(const BasicBlock *BB,
 DenseMap<const BasicBlock *, BBState> &BBStates,
 BBState &MyStates) const {
 // If any top-down local-use or possible-dec has a succ which is earlier in
 // the sequence, forget it.
-for (BBState::ptr_iterator I = MyStates.top_down_ptr_begin(),
+for (auto I = MyStates.top_down_ptr_begin(), E = MyStates.top_down_ptr_end();
-E = MyStates.top_down_ptr_end(); I != E; ++I) {
+I != E; ++I) {
-PtrState &S = I->second;
+TopDownPtrState &S = I->second;
 const Sequence Seq = I->second.GetSeq();
 // We only care about S_Retain, S_CanRelease, and S_Use.
 if (Seq == S_None)
 continue;
 // If VisitBottomUp has pointer information for this successor, take
 // what we know about it.
 const DenseMap<const BasicBlock *, BBState>::iterator BBI =
 BBStates.find(*SI);
 assert(BBI != BBStates.end());
-const PtrState &SuccS = BBI->second.getPtrBottomUpState(Arg);
+const BottomUpPtrState &SuccS = BBI->second.getPtrBottomUpState(Arg);
 const Sequence SuccSSeq = SuccS.GetSeq();
 // If bottom up, the pointer is in an S_None state, clear the sequence
 // progress since the sequence in the bottom up state finished
 // suggesting a mismatch in between retains/releases. This is true for
 S.SetCFGHazardAfflicted(true);
 }
 }
 }
-bool
+bool ObjCARCOpt::VisitInstructionBottomUp(
-ObjCARCOpt::VisitInstructionBottomUp(Instruction *Inst,
+Instruction *Inst, BasicBlock *BB, BlotMapVector<Value *, RRInfo> &Retains,
-BasicBlock *BB,
+BBState &MyStates) {
-MapVector<Value *, RRInfo> &Retains,
-BBState &MyStates) {
 bool NestingDetected = false;
-InstructionClass Class = GetInstructionClass(Inst);
+ARCInstKind Class = GetARCInstKind(Inst);
 const Value *Arg = nullptr;
-DEBUG(dbgs() << "Class: " << Class << "\n");
+DEBUG(dbgs() << "        Class: " << Class << "\n");
 switch (Class) {
-case IC_Release: {
+case ARCInstKind::Release: {
-Arg = GetObjCArg(Inst);
+Arg = GetArgRCIdentityRoot(Inst);
-PtrState &S = MyStates.getPtrBottomUpState(Arg);
+BottomUpPtrState &S = MyStates.getPtrBottomUpState(Arg);
+NestingDetected |= S.InitBottomUp(MDKindCache, Inst);
-// If we see two releases in a row on the same pointer. If so, make
-// a note, and we'll cicle back to revisit it after we've
-// hopefully eliminated the second release, which may allow us to
-// eliminate the first release too.
-// Theoretically we could implement removal of nested retain+release
-// pairs by making PtrState hold a stack of states, but this is
-// simple and avoids adding overhead for the non-nested case.
-if (S.GetSeq() == S_Release || S.GetSeq() == S_MovableRelease) {
-DEBUG(dbgs() << "Found nested releases (i.e. a release pair)\n");
-NestingDetected = true;
-}
-MDNode *ReleaseMetadata = Inst->getMetadata(ImpreciseReleaseMDKind);
-Sequence NewSeq = ReleaseMetadata ? S_MovableRelease : S_Release;
-ANNOTATE_BOTTOMUP(Inst, Arg, S.GetSeq(), NewSeq);
-S.ResetSequenceProgress(NewSeq);
-S.SetReleaseMetadata(ReleaseMetadata);
-S.SetKnownSafe(S.HasKnownPositiveRefCount());
-S.SetTailCallRelease(cast<CallInst>(Inst)->isTailCall());
-S.InsertCall(Inst);
-S.SetKnownPositiveRefCount();
 break;
 }
-case IC_RetainBlock:
+case ARCInstKind::RetainBlock:
 // In OptimizeIndividualCalls, we have strength reduced all optimizable
 // objc_retainBlocks to objc_retains. Thus at this point any
 // objc_retainBlocks that we see are not optimizable.
 break;
-case IC_Retain:
+case ARCInstKind::Retain:
-case IC_RetainRV: {
+case ARCInstKind::RetainRV: {
-Arg = GetObjCArg(Inst);
+Arg = GetArgRCIdentityRoot(Inst);
+BottomUpPtrState &S = MyStates.getPtrBottomUpState(Arg);
-PtrState &S = MyStates.getPtrBottomUpState(Arg);
+if (S.MatchWithRetain()) {
-S.SetKnownPositiveRefCount();
+// Don't do retain+release tracking for ARCInstKind::RetainRV, because
+// it's better to let it remain as the first instruction after a call.
-Sequence OldSeq = S.GetSeq();
+if (Class != ARCInstKind::RetainRV) {
-switch (OldSeq) {
+DEBUG(llvm::dbgs() << "        Matching with: " << *Inst << "\n");
-case S_Stop:
-case S_Release:
-case S_MovableRelease:
-case S_Use:
-// If OldSeq is not S_Use or OldSeq is S_Use and we are tracking an
-// imprecise release, clear our reverse insertion points.
-if (OldSeq != S_Use || S.IsTrackingImpreciseReleases())
-S.ClearReverseInsertPts();
-// FALL THROUGH
-case S_CanRelease:
-// Don't do retain+release tracking for IC_RetainRV, because it's
-// better to let it remain as the first instruction after a call.
-if (Class != IC_RetainRV)
 Retains[Inst] = S.GetRRInfo();
+}
 S.ClearSequenceProgress();
-break;
+}
-case S_None:
-break;
-case S_Retain:
-llvm_unreachable("bottom-up pointer in retain state!");
-}
-ANNOTATE_BOTTOMUP(Inst, Arg, OldSeq, S.GetSeq());
 // A retain moving bottom up can be a use.
 break;
 }
-case IC_AutoreleasepoolPop:
+case ARCInstKind::AutoreleasepoolPop:
 // Conservatively, clear MyStates for all known pointers.
 MyStates.clearBottomUpPointers();
 return NestingDetected;
-case IC_AutoreleasepoolPush:
+case ARCInstKind::AutoreleasepoolPush:
-case IC_None:
+case ARCInstKind::None:
 // These are irrelevant.
 return NestingDetected;
-case IC_User:
+case ARCInstKind::User:
 // If we have a store into an alloca of a pointer we are tracking, the
 // pointer has multiple owners implying that we must be more conservative.
 //
 // This comes up in the context of a pointer being ``KnownSafe''. In the
 // presence of a block being initialized, the frontend will emit the
 // one direction, will match the inner retain on the original pointer with
 // the guard release on the original pointer. This is fixed by ensuring that
 // in the presence of allocas we only unconditionally remove pointers if
 // both our retain and our release are KnownSafe.
 if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
-if (AreAnyUnderlyingObjectsAnAlloca(SI->getPointerOperand())) {
+const DataLayout &DL = BB->getModule()->getDataLayout();
-BBState::ptr_iterator I = MyStates.findPtrBottomUpState(
+if (AreAnyUnderlyingObjectsAnAlloca(SI->getPointerOperand(), DL)) {
-StripPointerCastsAndObjCCalls(SI->getValueOperand()));
+auto I = MyStates.findPtrBottomUpState(
+GetRCIdentityRoot(SI->getValueOperand()));
 if (I != MyStates.bottom_up_ptr_end())
 MultiOwnersSet.insert(I->first);
 }
 }
 break;
 break;
 }
 // Consider any other possible effects of this instruction on each
 // pointer being tracked.
-for (BBState::ptr_iterator MI = MyStates.bottom_up_ptr_begin(),
+for (auto MI = MyStates.bottom_up_ptr_begin(),
-ME = MyStates.bottom_up_ptr_end(); MI != ME; ++MI) {
+ME = MyStates.bottom_up_ptr_end();
+MI != ME; ++MI) {
 const Value *Ptr = MI->first;
 if (Ptr == Arg)
 continue; // Handled above.
-PtrState &S = MI->second;
+BottomUpPtrState &S = MI->second;
-Sequence Seq = S.GetSeq();
+if (S.HandlePotentialAlterRefCount(Inst, Ptr, PA, Class))
-// Check for possible releases.
+continue;
-if (CanAlterRefCount(Inst, Ptr, PA, Class)) {
-DEBUG(dbgs() << "CanAlterRefCount: Seq: " << Seq << "; " << *Ptr
+S.HandlePotentialUse(BB, Inst, Ptr, PA, Class);
-<< "\n");
-S.ClearKnownPositiveRefCount();
-switch (Seq) {
-case S_Use:
-S.SetSeq(S_CanRelease);
-ANNOTATE_BOTTOMUP(Inst, Ptr, Seq, S.GetSeq());
-continue;
-case S_CanRelease:
-case S_Release:
-case S_MovableRelease:
-case S_Stop:
-case S_None:
-break;
-case S_Retain:
-llvm_unreachable("bottom-up pointer in retain state!");
-}
-}
-// Check for possible direct uses.
-switch (Seq) {
-case S_Release:
-case S_MovableRelease:
-if (CanUse(Inst, Ptr, PA, Class)) {
-DEBUG(dbgs() << "CanUse: Seq: " << Seq << "; " << *Ptr
-<< "\n");
-assert(!S.HasReverseInsertPts());
-// If this is an invoke instruction, we're scanning it as part of
-// one of its successor blocks, since we can't insert code after it
-// in its own block, and we don't want to split critical edges.
-if (isa<InvokeInst>(Inst))
-S.InsertReverseInsertPt(BB->getFirstInsertionPt());
-else
-S.InsertReverseInsertPt(std::next(BasicBlock::iterator(Inst)));
-S.SetSeq(S_Use);
-ANNOTATE_BOTTOMUP(Inst, Ptr, Seq, S_Use);
-} else if (Seq == S_Release && IsUser(Class)) {
-DEBUG(dbgs() << "PreciseReleaseUse: Seq: " << Seq << "; " << *Ptr
-<< "\n");
-// Non-movable releases depend on any possible objc pointer use.
-S.SetSeq(S_Stop);
-ANNOTATE_BOTTOMUP(Inst, Ptr, S_Release, S_Stop);
-assert(!S.HasReverseInsertPts());
-// As above; handle invoke specially.
-if (isa<InvokeInst>(Inst))
-S.InsertReverseInsertPt(BB->getFirstInsertionPt());
-else
-S.InsertReverseInsertPt(std::next(BasicBlock::iterator(Inst)));
-}
-break;
-case S_Stop:
-if (CanUse(Inst, Ptr, PA, Class)) {
-DEBUG(dbgs() << "PreciseStopUse: Seq: " << Seq << "; " << *Ptr
-<< "\n");
-S.SetSeq(S_Use);
-ANNOTATE_BOTTOMUP(Inst, Ptr, Seq, S_Use);
-}
-break;
-case S_CanRelease:
-case S_Use:
-case S_None:
-break;
-case S_Retain:
-llvm_unreachable("bottom-up pointer in retain state!");
-}
 }
 return NestingDetected;
 }
-bool
+bool ObjCARCOpt::VisitBottomUp(BasicBlock *BB,
-ObjCARCOpt::VisitBottomUp(BasicBlock *BB,
+DenseMap<const BasicBlock *, BBState> &BBStates,
-DenseMap<const BasicBlock *, BBState> &BBStates,
+BlotMapVector<Value *, RRInfo> &Retains) {
-MapVector<Value *, RRInfo> &Retains) {
 DEBUG(dbgs() << "\n== ObjCARCOpt::VisitBottomUp ==\n");
 bool NestingDetected = false;
 BBState &MyStates = BBStates[BB];
 assert(I != BBStates.end());
 MyStates.MergeSucc(I->second);
 }
 }
-// If ARC Annotations are enabled, output the current state of pointers at the
+DEBUG(llvm::dbgs() << "Before:\n" << BBStates[BB] << "\n"
-// bottom of the basic block.
+<< "Performing Dataflow:\n");
-ANNOTATE_BOTTOMUP_BBEND(MyStates, BB);
 // Visit all the instructions, bottom-up.
 for (BasicBlock::iterator I = BB->end(), E = BB->begin(); I != E; --I) {
 Instruction *Inst = std::prev(I);
 // Invoke instructions are visited as part of their successors (below).
 if (isa<InvokeInst>(Inst))
 continue;
-DEBUG(dbgs() << "Visiting " << *Inst << "\n");
+DEBUG(dbgs() << "    Visiting " << *Inst << "\n");
 NestingDetected |= VisitInstructionBottomUp(Inst, BB, Retains, MyStates);
 }
 // If there's a predecessor with an invoke, visit the invoke as if it were
 BasicBlock *Pred = *PI;
 if (InvokeInst *II = dyn_cast<InvokeInst>(&Pred->back()))
 NestingDetected |= VisitInstructionBottomUp(II, BB, Retains, MyStates);
 }
-// If ARC Annotations are enabled, output the current state of pointers at the
+DEBUG(llvm::dbgs() << "\nFinal State:\n" << BBStates[BB] << "\n");
-// top of the basic block.
-ANNOTATE_BOTTOMUP_BBSTART(MyStates, BB);
 return NestingDetected;
 }
 bool
 ObjCARCOpt::VisitInstructionTopDown(Instruction *Inst,
 DenseMap<Value *, RRInfo> &Releases,
 BBState &MyStates) {
 bool NestingDetected = false;
-InstructionClass Class = GetInstructionClass(Inst);
+ARCInstKind Class = GetARCInstKind(Inst);
 const Value *Arg = nullptr;
+DEBUG(llvm::dbgs() << "        Class: " << Class << "\n");
 switch (Class) {
-case IC_RetainBlock:
+case ARCInstKind::RetainBlock:
 // In OptimizeIndividualCalls, we have strength reduced all optimizable
 // objc_retainBlocks to objc_retains. Thus at this point any
-// objc_retainBlocks that we see are not optimizable.
+// objc_retainBlocks that we see are not optimizable. We need to break since
+// a retain can be a potential use.
 break;
-case IC_Retain:
+case ARCInstKind::Retain:
-case IC_RetainRV: {
+case ARCInstKind::RetainRV: {
-Arg = GetObjCArg(Inst);
+Arg = GetArgRCIdentityRoot(Inst);
+TopDownPtrState &S = MyStates.getPtrTopDownState(Arg);
-PtrState &S = MyStates.getPtrTopDownState(Arg);
+NestingDetected |= S.InitTopDown(Class, Inst);
+// A retain can be a potential use; proceed to the generic checking
-// Don't do retain+release tracking for IC_RetainRV, because it's
-// better to let it remain as the first instruction after a call.
-if (Class != IC_RetainRV) {
-// If we see two retains in a row on the same pointer. If so, make
-// a note, and we'll cicle back to revisit it after we've
-// hopefully eliminated the second retain, which may allow us to
-// eliminate the first retain too.
-// Theoretically we could implement removal of nested retain+release
-// pairs by making PtrState hold a stack of states, but this is
-// simple and avoids adding overhead for the non-nested case.
-if (S.GetSeq() == S_Retain)
-NestingDetected = true;
-ANNOTATE_TOPDOWN(Inst, Arg, S.GetSeq(), S_Retain);
-S.ResetSequenceProgress(S_Retain);
-S.SetKnownSafe(S.HasKnownPositiveRefCount());
-S.InsertCall(Inst);
-}
-S.SetKnownPositiveRefCount();
-// A retain can be a potential use; procede to the generic checking
 // code below.
 break;
 }
-case IC_Release: {
+case ARCInstKind::Release: {
-Arg = GetObjCArg(Inst);
+Arg = GetArgRCIdentityRoot(Inst);
+TopDownPtrState &S = MyStates.getPtrTopDownState(Arg);
-PtrState &S = MyStates.getPtrTopDownState(Arg);
+// Try to form a tentative pair in between this release instruction and the
-S.ClearKnownPositiveRefCount();
+// top down pointers that we are tracking.
+if (S.MatchWithRelease(MDKindCache, Inst)) {
-Sequence OldSeq = S.GetSeq();
+// If we succeed, copy S's RRInfo into the Release -> {Retain Set
+// Map}. Then we clear S.
-MDNode *ReleaseMetadata = Inst->getMetadata(ImpreciseReleaseMDKind);
+DEBUG(llvm::dbgs() << "        Matching with: " << *Inst << "\n");
-switch (OldSeq) {
-case S_Retain:
-case S_CanRelease:
-if (OldSeq == S_Retain || ReleaseMetadata != nullptr)
-S.ClearReverseInsertPts();
-// FALL THROUGH
-case S_Use:
-S.SetReleaseMetadata(ReleaseMetadata);
-S.SetTailCallRelease(cast<CallInst>(Inst)->isTailCall());
 Releases[Inst] = S.GetRRInfo();
-ANNOTATE_TOPDOWN(Inst, Arg, S.GetSeq(), S_None);
 S.ClearSequenceProgress();
-break;
-case S_None:
-break;
-case S_Stop:
-case S_Release:
-case S_MovableRelease:
-llvm_unreachable("top-down pointer in release state!");
 }
 break;
 }
-case IC_AutoreleasepoolPop:
+case ARCInstKind::AutoreleasepoolPop:
 // Conservatively, clear MyStates for all known pointers.
 MyStates.clearTopDownPointers();
-return NestingDetected;
+return false;
-case IC_AutoreleasepoolPush:
+case ARCInstKind::AutoreleasepoolPush:
-case IC_None:
+case ARCInstKind::None:
-// These are irrelevant.
+// These can not be uses of
-return NestingDetected;
+return false;
 default:
 break;
 }
 // Consider any other possible effects of this instruction on each
 // pointer being tracked.
-for (BBState::ptr_iterator MI = MyStates.top_down_ptr_begin(),
+for (auto MI = MyStates.top_down_ptr_begin(),
-ME = MyStates.top_down_ptr_end(); MI != ME; ++MI) {
+ME = MyStates.top_down_ptr_end();
+MI != ME; ++MI) {
 const Value *Ptr = MI->first;
 if (Ptr == Arg)
 continue; // Handled above.
-PtrState &S = MI->second;
+TopDownPtrState &S = MI->second;
-Sequence Seq = S.GetSeq();
+if (S.HandlePotentialAlterRefCount(Inst, Ptr, PA, Class))
+continue;
-// Check for possible releases.
-if (CanAlterRefCount(Inst, Ptr, PA, Class)) {
+S.HandlePotentialUse(Inst, Ptr, PA, Class);
-DEBUG(dbgs() << "CanAlterRefCount: Seq: " << Seq << "; " << *Ptr
-<< "\n");
-S.ClearKnownPositiveRefCount();
-switch (Seq) {
-case S_Retain:
-S.SetSeq(S_CanRelease);
-ANNOTATE_TOPDOWN(Inst, Ptr, Seq, S_CanRelease);
-assert(!S.HasReverseInsertPts());
-S.InsertReverseInsertPt(Inst);
-// One call can't cause a transition from S_Retain to S_CanRelease
-// and S_CanRelease to S_Use. If we've made the first transition,
-// we're done.
-continue;
-case S_Use:
-case S_CanRelease:
-case S_None:
-break;
-case S_Stop:
-case S_Release:
-case S_MovableRelease:
-llvm_unreachable("top-down pointer in release state!");
-}
-}
-// Check for possible direct uses.
-switch (Seq) {
-case S_CanRelease:
-if (CanUse(Inst, Ptr, PA, Class)) {
-DEBUG(dbgs() << "CanUse: Seq: " << Seq << "; " << *Ptr
-<< "\n");
-S.SetSeq(S_Use);
-ANNOTATE_TOPDOWN(Inst, Ptr, Seq, S_Use);
-}
-break;
-case S_Retain:
-case S_Use:
-case S_None:
-break;
-case S_Stop:
-case S_Release:
-case S_MovableRelease:
-llvm_unreachable("top-down pointer in release state!");
-}
 }
 return NestingDetected;
 }
 assert(I != BBStates.end());
 MyStates.MergePred(I->second);
 }
 }
-// If ARC Annotations are enabled, output the current state of pointers at the
+DEBUG(llvm::dbgs() << "Before:\n" << BBStates[BB]  << "\n"
-// top of the basic block.
+<< "Performing Dataflow:\n");
-ANNOTATE_TOPDOWN_BBSTART(MyStates, BB);
 // Visit all the instructions, top-down.
 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
 Instruction *Inst = I;
-DEBUG(dbgs() << "Visiting " << *Inst << "\n");
+DEBUG(dbgs() << "    Visiting " << *Inst << "\n");
 NestingDetected |= VisitInstructionTopDown(Inst, Releases, MyStates);
 }
-// If ARC Annotations are enabled, output the current state of pointers at the
+DEBUG(llvm::dbgs() << "\nState Before Checking for CFG Hazards:\n"
-// bottom of the basic block.
+<< BBStates[BB] << "\n\n");
-ANNOTATE_TOPDOWN_BBEND(MyStates, BB);
-#ifdef ARC_ANNOTATIONS
-if (!(EnableARCAnnotations && DisableCheckForCFGHazards))
-#endif
 CheckForCFGHazards(BB, BBStates, MyStates);
+DEBUG(llvm::dbgs() << "Final State:\n" << BBStates[BB] << "\n");
 return NestingDetected;
 }
 static void
 ComputePostOrders(Function &F,
 }
 }
 }
 // Visit the function both top-down and bottom-up.
-bool
+bool ObjCARCOpt::Visit(Function &F,
-ObjCARCOpt::Visit(Function &F,
+DenseMap<const BasicBlock *, BBState> &BBStates,
-DenseMap<const BasicBlock *, BBState> &BBStates,
+BlotMapVector<Value *, RRInfo> &Retains,
-MapVector<Value *, RRInfo> &Retains,
+DenseMap<Value *, RRInfo> &Releases) {
-DenseMap<Value *, RRInfo> &Releases) {
 // Use reverse-postorder traversals, because we magically know that loops
 // will be well behaved, i.e. they won't repeatedly call retain on a single
 // pointer without doing a release. We can't use the ReversePostOrderTraversal
 // class here because we want the reverse-CFG postorder to consider each
 // function exit point, and we want to ignore selected cycle edges.
 SmallVector<BasicBlock *, 16> PostOrder;
 SmallVector<BasicBlock *, 16> ReverseCFGPostOrder;
 ComputePostOrders(F, PostOrder, ReverseCFGPostOrder,
-NoObjCARCExceptionsMDKind,
+MDKindCache.get(ARCMDKindID::NoObjCARCExceptions),
 BBStates);
 // Use reverse-postorder on the reverse CFG for bottom-up.
 bool BottomUpNestingDetected = false;
 for (SmallVectorImpl<BasicBlock *>::const_reverse_iterator I =
 return TopDownNestingDetected && BottomUpNestingDetected;
 }
 /// Move the calls in RetainsToMove and ReleasesToMove.
-void ObjCARCOpt::MoveCalls(Value *Arg,
+void ObjCARCOpt::MoveCalls(Value *Arg, RRInfo &RetainsToMove,
-RRInfo &RetainsToMove,
 RRInfo &ReleasesToMove,
-MapVector<Value *, RRInfo> &Retains,
+BlotMapVector<Value *, RRInfo> &Retains,
 DenseMap<Value *, RRInfo> &Releases,
 SmallVectorImpl<Instruction *> &DeadInsts,
 Module *M) {
 Type *ArgTy = Arg->getType();
 Type *ParamTy = PointerType::getUnqual(Type::getInt8Ty(ArgTy->getContext()));
 // Insert the new retain and release calls.
 for (Instruction *InsertPt : ReleasesToMove.ReverseInsertPts) {
 Value *MyArg = ArgTy == ParamTy ? Arg :
 new BitCastInst(Arg, ParamTy, "", InsertPt);
-Constant *Decl = EP.get(ARCRuntimeEntryPoints::EPT_Retain);
+Constant *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
 CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
 Call->setDoesNotThrow();
 Call->setTailCall();
 DEBUG(dbgs() << "Inserting new Retain: " << *Call << "\n"
 "At insertion point: " << *InsertPt << "\n");
 }
 for (Instruction *InsertPt : RetainsToMove.ReverseInsertPts) {
 Value *MyArg = ArgTy == ParamTy ? Arg :
 new BitCastInst(Arg, ParamTy, "", InsertPt);
-Constant *Decl = EP.get(ARCRuntimeEntryPoints::EPT_Release);
+Constant *Decl = EP.get(ARCRuntimeEntryPointKind::Release);
 CallInst *Call = CallInst::Create(Decl, MyArg, "", InsertPt);
 // Attach a clang.imprecise_release metadata tag, if appropriate.
 if (MDNode *M = ReleasesToMove.ReleaseMetadata)
-Call->setMetadata(ImpreciseReleaseMDKind, M);
+Call->setMetadata(MDKindCache.get(ARCMDKindID::ImpreciseRelease), M);
 Call->setDoesNotThrow();
 if (ReleasesToMove.IsTailCallRelease)
 Call->setTailCall();
 DEBUG(dbgs() << "Inserting new Release: " << *Call << "\n"
 DEBUG(dbgs() << "Deleting release: " << *OrigRelease << "\n");
 }
 }
-bool
+bool ObjCARCOpt::PairUpRetainsAndReleases(
-ObjCARCOpt::ConnectTDBUTraversals(DenseMap<const BasicBlock *, BBState>
+DenseMap<const BasicBlock *, BBState> &BBStates,
-&BBStates,
+BlotMapVector<Value *, RRInfo> &Retains,
-MapVector<Value *, RRInfo> &Retains,
+DenseMap<Value *, RRInfo> &Releases, Module *M,
-DenseMap<Value *, RRInfo> &Releases,
+SmallVectorImpl<Instruction *> &NewRetains,
-Module *M,
+SmallVectorImpl<Instruction *> &NewReleases,
-SmallVectorImpl<Instruction *> &NewRetains,
+SmallVectorImpl<Instruction *> &DeadInsts, RRInfo &RetainsToMove,
-SmallVectorImpl<Instruction *> &NewReleases,
+RRInfo &ReleasesToMove, Value *Arg, bool KnownSafe,
-SmallVectorImpl<Instruction *> &DeadInsts,
+bool &AnyPairsCompletelyEliminated) {
-RRInfo &RetainsToMove,
-RRInfo &ReleasesToMove,
-Value *Arg,
-bool KnownSafe,
-bool &AnyPairsCompletelyEliminated) {
 // If a pair happens in a region where it is known that the reference count
 // is already incremented, we can similarly ignore possible decrements unless
 // we are dealing with a retainable object with multiple provenance sources.
 bool KnownSafeTD = true, KnownSafeBU = true;
 bool MultipleOwners = false;
 bool FirstRelease = true;
 for (;;) {
 for (SmallVectorImpl<Instruction *>::const_iterator
 NI = NewRetains.begin(), NE = NewRetains.end(); NI != NE; ++NI) {
 Instruction *NewRetain = *NI;
-MapVector<Value *, RRInfo>::const_iterator It = Retains.find(NewRetain);
+auto It = Retains.find(NewRetain);
 assert(It != Retains.end());
 const RRInfo &NewRetainRRI = It->second;
 KnownSafeTD &= NewRetainRRI.KnownSafe;
 MultipleOwners =
-MultipleOwners || MultiOwnersSet.count(GetObjCArg(NewRetain));
+MultipleOwners || MultiOwnersSet.count(GetArgRCIdentityRoot(NewRetain));
 for (Instruction *NewRetainRelease : NewRetainRRI.Calls) {
-DenseMap<Value *, RRInfo>::const_iterator Jt =
+auto Jt = Releases.find(NewRetainRelease);
-Releases.find(NewRetainRelease);
 if (Jt == Releases.end())
 return false;
 const RRInfo &NewRetainReleaseRRI = Jt->second;
 // If the release does not have a reference to the retain as well,
 // Back the other way.
 for (SmallVectorImpl<Instruction *>::const_iterator
 NI = NewReleases.begin(), NE = NewReleases.end(); NI != NE; ++NI) {
 Instruction *NewRelease = *NI;
-DenseMap<Value *, RRInfo>::const_iterator It =
+auto It = Releases.find(NewRelease);
-Releases.find(NewRelease);
 assert(It != Releases.end());
 const RRInfo &NewReleaseRRI = It->second;
 KnownSafeBU &= NewReleaseRRI.KnownSafe;
 CFGHazardAfflicted |= NewReleaseRRI.CFGHazardAfflicted;
 for (Instruction *NewReleaseRetain : NewReleaseRRI.Calls) {
-MapVector<Value *, RRInfo>::const_iterator Jt =
+auto Jt = Retains.find(NewReleaseRetain);
-Retains.find(NewReleaseRetain);
 if (Jt == Retains.end())
 return false;
 const RRInfo &NewReleaseRetainRRI = Jt->second;
 // If the retain does not have a reference to the release as well,
 }
 NewReleases.clear();
 if (NewRetains.empty()) break;
 }
-// If the pointer is known incremented in 1 direction and we do not have
+// We can only remove pointers if we are known safe in both directions.
-// MultipleOwners, we can safely remove the retain/releases. Otherwise we need
+bool UnconditionallySafe = KnownSafeTD && KnownSafeBU;
-// to be known safe in both directions.
-bool UnconditionallySafe = (KnownSafeTD && KnownSafeBU) ||
-((KnownSafeTD || KnownSafeBU) && !MultipleOwners);
 if (UnconditionallySafe) {
 RetainsToMove.ReverseInsertPts.clear();
 ReleasesToMove.ReverseInsertPts.clear();
 NewCount = 0;
 } else {
 // TODO: It's theoretically possible to do code motion in this case, as
 // long as the existing imbalances are maintained.
 if (OldDelta != 0)
 return false;
-#ifdef ARC_ANNOTATIONS
-// Do not move calls if ARC annotations are requested.
-if (EnableARCAnnotations)
-return false;
-#endif // ARC_ANNOTATIONS
 Changed = true;
 assert(OldCount != 0 && "Unreachable code?");
 NumRRs += OldCount - NewCount;
 // Set to true if we completely removed any RR pairs.
 AnyPairsCompletelyEliminated = NewCount == 0;
 return true;
 }
 /// Identify pairings between the retains and releases, and delete and/or move
 /// them.
-bool
+bool ObjCARCOpt::PerformCodePlacement(
-ObjCARCOpt::PerformCodePlacement(DenseMap<const BasicBlock *, BBState>
+DenseMap<const BasicBlock *, BBState> &BBStates,
-&BBStates,
+BlotMapVector<Value *, RRInfo> &Retains,
-MapVector<Value *, RRInfo> &Retains,
+DenseMap<Value *, RRInfo> &Releases, Module *M) {
-DenseMap<Value *, RRInfo> &Releases,
-Module *M) {
 DEBUG(dbgs() << "\n== ObjCARCOpt::PerformCodePlacement ==\n");
 bool AnyPairsCompletelyEliminated = false;
 RRInfo RetainsToMove;
 RRInfo ReleasesToMove;
 SmallVector<Instruction *, 4> NewRetains;
 SmallVector<Instruction *, 4> NewReleases;
 SmallVector<Instruction *, 8> DeadInsts;
 // Visit each retain.
-for (MapVector<Value *, RRInfo>::const_iterator I = Retains.begin(),
+for (BlotMapVector<Value *, RRInfo>::const_iterator I = Retains.begin(),
-E = Retains.end(); I != E; ++I) {
+E = Retains.end();
+I != E; ++I) {
 Value *V = I->first;
 if (!V) continue; // blotted
 Instruction *Retain = cast<Instruction>(V);
 DEBUG(dbgs() << "Visiting: " << *Retain << "\n");
-Value *Arg = GetObjCArg(Retain);
+Value *Arg = GetArgRCIdentityRoot(Retain);
 // If the object being released is in static or stack storage, we know it's
 // not being managed by ObjC reference counting, so we can delete pairs
 // regardless of what possible decrements or uses lie between them.
 bool KnownSafe = isa<Constant>(Arg) || isa<AllocaInst>(Arg);
 // A constant pointer can't be pointing to an object on the heap. It may
 // be reference-counted, but it won't be deleted.
 if (const LoadInst *LI = dyn_cast<LoadInst>(Arg))
 if (const GlobalVariable *GV =
 dyn_cast<GlobalVariable>(
-StripPointerCastsAndObjCCalls(LI->getPointerOperand())))
+GetRCIdentityRoot(LI->getPointerOperand())))
 if (GV->isConstant())
 KnownSafe = true;
 // Connect the dots between the top-down-collected RetainsToMove and
 // bottom-up-collected ReleasesToMove to form sets of related calls.
 NewRetains.push_back(Retain);
-bool PerformMoveCalls =
+bool PerformMoveCalls = PairUpRetainsAndReleases(
-ConnectTDBUTraversals(BBStates, Retains, Releases, M, NewRetains,
+BBStates, Retains, Releases, M, NewRetains, NewReleases, DeadInsts,
-NewReleases, DeadInsts, RetainsToMove,
+RetainsToMove, ReleasesToMove, Arg, KnownSafe,
-ReleasesToMove, Arg, KnownSafe,
+AnyPairsCompletelyEliminated);
-AnyPairsCompletelyEliminated);
 if (PerformMoveCalls) {
 // Ok, everything checks out and we're all set. Let's move/delete some
 // code!
 MoveCalls(Arg, RetainsToMove, ReleasesToMove,
 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
 Instruction *Inst = &*I++;
 DEBUG(dbgs() << "Visiting: " << *Inst << "\n");
-InstructionClass Class = GetBasicInstructionClass(Inst);
+ARCInstKind Class = GetBasicARCInstKind(Inst);
-if (Class != IC_LoadWeak && Class != IC_LoadWeakRetained)
+if (Class != ARCInstKind::LoadWeak &&
+Class != ARCInstKind::LoadWeakRetained)
 continue;
 // Delete objc_loadWeak calls with no users.
-if (Class == IC_LoadWeak && Inst->use_empty()) {
+if (Class == ARCInstKind::LoadWeak && Inst->use_empty()) {
 Inst->eraseFromParent();
 continue;
 }
 // TODO: For now, just look for an earlier available version of this value
 BasicBlock *CurrentBB = Current.getBasicBlockIterator();
 for (BasicBlock::iterator B = CurrentBB->begin(),
 J = Current.getInstructionIterator();
 J != B; --J) {
 Instruction *EarlierInst = &*std::prev(J);
-InstructionClass EarlierClass = GetInstructionClass(EarlierInst);
+ARCInstKind EarlierClass = GetARCInstKind(EarlierInst);
 switch (EarlierClass) {
-case IC_LoadWeak:
+case ARCInstKind::LoadWeak:
-case IC_LoadWeakRetained: {
+case ARCInstKind::LoadWeakRetained: {
 // If this is loading from the same pointer, replace this load's value
 // with that one.
 CallInst *Call = cast<CallInst>(Inst);
 CallInst *EarlierCall = cast<CallInst>(EarlierInst);
 Value *Arg = Call->getArgOperand(0);
 Value *EarlierArg = EarlierCall->getArgOperand(0);
 switch (PA.getAA()->alias(Arg, EarlierArg)) {
-case AliasAnalysis::MustAlias:
+case MustAlias:
 Changed = true;
 // If the load has a builtin retain, insert a plain retain for it.
-if (Class == IC_LoadWeakRetained) {
+if (Class == ARCInstKind::LoadWeakRetained) {
-Constant *Decl = EP.get(ARCRuntimeEntryPoints::EPT_Retain);
+Constant *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
 CallInst *CI = CallInst::Create(Decl, EarlierCall, "", Call);
 CI->setTailCall();
 }
 // Zap the fully redundant load.
 Call->replaceAllUsesWith(EarlierCall);
 Call->eraseFromParent();
 goto clobbered;
-case AliasAnalysis::MayAlias:
+case MayAlias:
-case AliasAnalysis::PartialAlias:
+case PartialAlias:
 goto clobbered;
-case AliasAnalysis::NoAlias:
+case NoAlias:
 break;
 }
 break;
 }
-case IC_StoreWeak:
+case ARCInstKind::StoreWeak:
-case IC_InitWeak: {
+case ARCInstKind::InitWeak: {
 // If this is storing to the same pointer and has the same size etc.
 // replace this load's value with the stored value.
 CallInst *Call = cast<CallInst>(Inst);
 CallInst *EarlierCall = cast<CallInst>(EarlierInst);
 Value *Arg = Call->getArgOperand(0);
 Value *EarlierArg = EarlierCall->getArgOperand(0);
 switch (PA.getAA()->alias(Arg, EarlierArg)) {
-case AliasAnalysis::MustAlias:
+case MustAlias:
 Changed = true;
 // If the load has a builtin retain, insert a plain retain for it.
-if (Class == IC_LoadWeakRetained) {
+if (Class == ARCInstKind::LoadWeakRetained) {
-Constant *Decl = EP.get(ARCRuntimeEntryPoints::EPT_Retain);
+Constant *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
 CallInst *CI = CallInst::Create(Decl, EarlierCall, "", Call);
 CI->setTailCall();
 }
 // Zap the fully redundant load.
 Call->replaceAllUsesWith(EarlierCall->getArgOperand(1));
 Call->eraseFromParent();
 goto clobbered;
-case AliasAnalysis::MayAlias:
+case MayAlias:
-case AliasAnalysis::PartialAlias:
+case PartialAlias:
 goto clobbered;
-case AliasAnalysis::NoAlias:
+case NoAlias:
 break;
 }
 break;
 }
-case IC_MoveWeak:
+case ARCInstKind::MoveWeak:
-case IC_CopyWeak:
+case ARCInstKind::CopyWeak:
 // TOOD: Grab the copied value.
 goto clobbered;
-case IC_AutoreleasepoolPush:
+case ARCInstKind::AutoreleasepoolPush:
-case IC_None:
+case ARCInstKind::None:
-case IC_IntrinsicUser:
+case ARCInstKind::IntrinsicUser:
-case IC_User:
+case ARCInstKind::User:
 // Weak pointers are only modified through the weak entry points
 // (and arbitrary calls, which could call the weak entry points).
 break;
 default:
 // Anything else could modify the weak pointer.
 // Then, for each destroyWeak with an alloca operand, check to see if
 // the alloca and all its users can be zapped.
 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
 Instruction *Inst = &*I++;
-InstructionClass Class = GetBasicInstructionClass(Inst);
+ARCInstKind Class = GetBasicARCInstKind(Inst);
-if (Class != IC_DestroyWeak)
+if (Class != ARCInstKind::DestroyWeak)
 continue;
 CallInst *Call = cast<CallInst>(Inst);
 Value *Arg = Call->getArgOperand(0);
 if (AllocaInst *Alloca = dyn_cast<AllocaInst>(Arg)) {
 for (User *U : Alloca->users()) {
 const Instruction *UserInst = cast<Instruction>(U);
-switch (GetBasicInstructionClass(UserInst)) {
+switch (GetBasicARCInstKind(UserInst)) {
-case IC_InitWeak:
+case ARCInstKind::InitWeak:
-case IC_StoreWeak:
+case ARCInstKind::StoreWeak:
-case IC_DestroyWeak:
+case ARCInstKind::DestroyWeak:
 continue;
 default:
 goto done;
 }
 }
 Changed = true;
 for (auto UI = Alloca->user_begin(), UE = Alloca->user_end(); UI != UE;) {
 CallInst *UserInst = cast<CallInst>(*UI++);
-switch (GetBasicInstructionClass(UserInst)) {
+switch (GetBasicARCInstKind(UserInst)) {
-case IC_InitWeak:
+case ARCInstKind::InitWeak:
-case IC_StoreWeak:
+case ARCInstKind::StoreWeak:
 // These functions return their second argument.
 UserInst->replaceAllUsesWith(UserInst->getArgOperand(1));
 break;
-case IC_DestroyWeak:
+case ARCInstKind::DestroyWeak:
 // No return value.
 break;
 default:
 llvm_unreachable("alloca really is used!");
 }
 // Releases, Retains - These are used to store the results of the main flow
 // analysis. These use Value* as the key instead of Instruction* so that the
 // map stays valid when we get around to rewriting code and calls get
 // replaced by arguments.
 DenseMap<Value *, RRInfo> Releases;
-MapVector<Value *, RRInfo> Retains;
+BlotMapVector<Value *, RRInfo> Retains;
 // This is used during the traversal of the function to track the
 // states for each identified object at each block.
 DenseMap<const BasicBlock *, BBState> BBStates;
 FindDependencies(CanChangeRetainCount, Arg, Retain->getParent(), Retain,
 DepInsts, Visited, PA);
 if (DepInsts.size() != 1)
 return false;
-CallInst *Call =
+auto *Call = dyn_cast_or_null<CallInst>(*DepInsts.begin());
-dyn_cast_or_null<CallInst>(*DepInsts.begin());
 // Check that the pointer is the return value of the call.
 if (!Call || Arg != Call)
 return false;
 // Check that the call is a regular call.
-InstructionClass Class = GetBasicInstructionClass(Call);
+ARCInstKind Class = GetBasicARCInstKind(Call);
-if (Class != IC_CallOrUser && Class != IC_Call)
+if (Class != ARCInstKind::CallOrUser && Class != ARCInstKind::Call)
 return false;
 return true;
 }
 FindDependencies(CanChangeRetainCount, Arg,
 BB, Autorelease, DepInsts, Visited, PA);
 if (DepInsts.size() != 1)
 return nullptr;
-CallInst *Retain =
+auto *Retain = dyn_cast_or_null<CallInst>(*DepInsts.begin());
-dyn_cast_or_null<CallInst>(*DepInsts.begin());
 // Check that we found a retain with the same argument.
-if (!Retain ||
+if (!Retain || !IsRetain(GetBasicARCInstKind(Retain)) ||
-!IsRetain(GetBasicInstructionClass(Retain)) ||
+GetArgRCIdentityRoot(Retain) != Arg) {
-GetObjCArg(Retain) != Arg) {
 return nullptr;
 }
 return Retain;
 }
 FindDependencies(NeedsPositiveRetainCount, Arg,
 BB, Ret, DepInsts, V, PA);
 if (DepInsts.size() != 1)
 return nullptr;
-CallInst *Autorelease =
+auto *Autorelease = dyn_cast_or_null<CallInst>(*DepInsts.begin());
-dyn_cast_or_null<CallInst>(*DepInsts.begin());
 if (!Autorelease)
 return nullptr;
-InstructionClass AutoreleaseClass = GetBasicInstructionClass(Autorelease);
+ARCInstKind AutoreleaseClass = GetBasicARCInstKind(Autorelease);
 if (!IsAutorelease(AutoreleaseClass))
 return nullptr;
-if (GetObjCArg(Autorelease) != Arg)
+if (GetArgRCIdentityRoot(Autorelease) != Arg)
 return nullptr;
 return Autorelease;
 }
 DEBUG(dbgs() << "Visiting: " << *Ret << "\n");
 if (!Ret)
 continue;
-const Value *Arg = StripPointerCastsAndObjCCalls(Ret->getOperand(0));
+const Value *Arg = GetRCIdentityRoot(Ret->getOperand(0));
 // Look for an ``autorelease'' instruction that is a predecessor of Ret and
 // dependent on Arg such that there are no instructions dependent on Arg
 // that need a positive ref count in between the autorelease and Ret.
 CallInst *Autorelease =
 llvm::Statistic &NumReleases =
 AfterOptimization? NumReleasesAfterOpt : NumReleasesBeforeOpt;
 for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
 Instruction *Inst = &*I++;
-switch (GetBasicInstructionClass(Inst)) {
+switch (GetBasicARCInstKind(Inst)) {
 default:
 break;
-case IC_Retain:
+case ARCInstKind::Retain:
 ++NumRetains;
 break;
-case IC_Release:
+case ARCInstKind::Release:
 ++NumReleases;
 break;
 }
 }
 }
 // If nothing in the Module uses ARC, don't do anything.
 Run = ModuleHasARC(M);
 if (!Run)
 return false;
-// Identify the imprecise release metadata kind.
-ImpreciseReleaseMDKind =
-M.getContext().getMDKindID("clang.imprecise_release");
-CopyOnEscapeMDKind =
-M.getContext().getMDKindID("clang.arc.copy_on_escape");
-NoObjCARCExceptionsMDKind =
-M.getContext().getMDKindID("clang.arc.no_objc_arc_exceptions");
-#ifdef ARC_ANNOTATIONS
-ARCAnnotationBottomUpMDKind =
-M.getContext().getMDKindID("llvm.arc.annotation.bottomup");
-ARCAnnotationTopDownMDKind =
-M.getContext().getMDKindID("llvm.arc.annotation.topdown");
-ARCAnnotationProvenanceSourceMDKind =
-M.getContext().getMDKindID("llvm.arc.annotation.provenancesource");
-#endif // ARC_ANNOTATIONS
 // Intuitively, objc_retain and others are nocapture, however in practice
 // they are not, because they return their argument value. And objc_release
 // calls finalizers which can have arbitrary side effects.
+MDKindCache.init(&M);
 // Initialize our runtime entry point cache.
-EP.Initialize(&M);
+EP.init(&M);
 return false;
 }
 bool ObjCARCOpt::runOnFunction(Function &F) {
 Changed = false;
 DEBUG(dbgs() << "<<< ObjCARCOpt: Visiting Function: " << F.getName() << " >>>"
 "\n");
-PA.setAA(&getAnalysis<AliasAnalysis>());
+PA.setAA(&getAnalysis<AAResultsWrapperPass>().getAAResults());
 #ifndef NDEBUG
 if (AreStatisticsEnabled()) {
 GatherStatistics(F, false);
 }
 // Preliminary optimizations. This also computes UsedInThisFunction.
 OptimizeIndividualCalls(F);
 // Optimizations for weak pointers.
-if (UsedInThisFunction & ((1 << IC_LoadWeak) |
+if (UsedInThisFunction & ((1 << unsigned(ARCInstKind::LoadWeak)) |
-(1 << IC_LoadWeakRetained) |
+(1 << unsigned(ARCInstKind::LoadWeakRetained)) |
-(1 << IC_StoreWeak) |
+(1 << unsigned(ARCInstKind::StoreWeak)) |
-(1 << IC_InitWeak) |
+(1 << unsigned(ARCInstKind::InitWeak)) |
-(1 << IC_CopyWeak) |
+(1 << unsigned(ARCInstKind::CopyWeak)) |
-(1 << IC_MoveWeak) |
+(1 << unsigned(ARCInstKind::MoveWeak)) |
-(1 << IC_DestroyWeak)))
+(1 << unsigned(ARCInstKind::DestroyWeak))))
 OptimizeWeakCalls(F);
 // Optimizations for retain+release pairs.
-if (UsedInThisFunction & ((1 << IC_Retain) |
+if (UsedInThisFunction & ((1 << unsigned(ARCInstKind::Retain)) |
-(1 << IC_RetainRV) |
+(1 << unsigned(ARCInstKind::RetainRV)) |
-(1 << IC_RetainBlock)))
+(1 << unsigned(ARCInstKind::RetainBlock))))
-if (UsedInThisFunction & (1 << IC_Release))
+if (UsedInThisFunction & (1 << unsigned(ARCInstKind::Release)))
 // Run OptimizeSequences until it either stops making changes or
 // no retain+release pair nesting is detected.
 while (OptimizeSequences(F)) {}
 // Optimizations if objc_autorelease is used.
-if (UsedInThisFunction & ((1 << IC_Autorelease) |
+if (UsedInThisFunction & ((1 << unsigned(ARCInstKind::Autorelease)) |
-(1 << IC_AutoreleaseRV)))
+(1 << unsigned(ARCInstKind::AutoreleaseRV))))
 OptimizeReturns(F);
 // Gather statistics after optimization.
 #ifndef NDEBUG
 if (AreStatisticsEnabled()) {

Mercurial > hg > CbC > CbC_llvm

comparison lib/Transforms/ObjCARC/ObjCARCOpts.cpp @ 95:afa8332a0e37 LLVM3.8