Merge pull request #1338 from gottesmm/arc-make-trivial

gottesmm · gottesmm · commit 9638e2917e93 · 2016-02-17T17:02:16.000-08:00
[arc] Make all *RefCountStates and RCStateTransition trivially destru…
diff --git a/lib/SILOptimizer/ARC/RCStateTransition.cpp b/lib/SILOptimizer/ARC/RCStateTransition.cpp
@@ -121,18 +121,6 @@ raw_ostream &llvm::operator<<(raw_ostream &os, RCStateTransitionKind Kind) {
   }
 #include "RCStateTransition.def"
 
-RCStateTransition::RCStateTransition(const RCStateTransition &R) {
-  Kind = R.Kind;
-  if (R.isEndPoint()) {
-    EndPoint = R.EndPoint;
-    return;
-  }
-
-  if (!R.isMutator())
-    return;
-  Mutators = R.Mutators;
-}
-
 bool RCStateTransition::matchingInst(SILInstruction *Inst) const {
   // We only pair mutators for now.
   if (!isMutator())
diff --git a/lib/SILOptimizer/ARC/RCStateTransition.def b/lib/SILOptimizer/ARC/RCStateTransition.def
@@ -43,6 +43,8 @@
 /// Misc |
 ///-------
 ///
+/// An invalid transition kind. This must always be first so that it is zero.
+KIND(Invalid)
 /// An unknown kind.
 KIND(Unknown)
 /// An autorelease pool call.
diff --git a/lib/SILOptimizer/ARC/RCStateTransition.h b/lib/SILOptimizer/ARC/RCStateTransition.h
@@ -13,6 +13,7 @@
 #ifndef SWIFT_SILOPTIMIZER_PASSMANAGER_ARC_RCSTATETRANSITION_H
 #define SWIFT_SILOPTIMIZER_PASSMANAGER_ARC_RCSTATETRANSITION_H
 
+#include "swift/Basic/type_traits.h"
 #include "swift/Basic/ImmutablePointerSet.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILInstruction.h"
@@ -60,10 +61,14 @@ RCStateTransitionKind getRCStateTransitionKind(ValueBase *V);
 //===----------------------------------------------------------------------===//
 
 class RefCountState;
+class BottomUpRefCountState;
+class TopDownRefCountState;
 
 /// Represents a transition in the RC history of a ref count.
 class RCStateTransition {
   friend class RefCountState;
+  friend class BottomUpRefCountState;
+  friend class TopDownRefCountState;
 
   /// An RCStateTransition can represent either an RC end point (i.e. an initial
   /// or terminal RC transition) or a ptr set of Mutators.
@@ -73,11 +78,11 @@ class RCStateTransition {
   RCStateTransitionKind Kind;
 
   // Should only be constructed be default RefCountState.
-  RCStateTransition() {}
+  RCStateTransition() = default;
 
 public:
-  ~RCStateTransition() {}
-  RCStateTransition(const RCStateTransition &R);
+  ~RCStateTransition() = default;
+  RCStateTransition(const RCStateTransition &R) = default;
 
   RCStateTransition(ImmutablePointerSet<SILInstruction> *I) {
     assert(I->size() == 1);
@@ -132,8 +137,15 @@ class RCStateTransition {
   /// Attempt to merge \p Other into \p this. Returns true if we succeeded,
   /// false otherwise.
   bool merge(const RCStateTransition &Other);
+
+  /// Return true if the kind of this RCStateTransition is not 'Invalid'.
+  bool isValid() const { return getKind() != RCStateTransitionKind::Invalid; }
 };
 
+// These static assert checks are here for performance reasons.
+static_assert(IsTriviallyCopyable<RCStateTransition>::value,
+              "RCStateTransitions must be trivially copyable");
+
 } // end swift namespace
 
 namespace llvm {
diff --git a/lib/SILOptimizer/ARC/RefCountState.cpp b/lib/SILOptimizer/ARC/RefCountState.cpp
@@ -124,7 +124,7 @@ void BottomUpRefCountState::clear() {
   // be removed, be conservative and clear the transition state, so we do not
   // propagate KnownSafety forward.
   if (mightRemoveMutators())
-    Transition = None;
+    Transition = RCStateTransition();
   LatState = LatticeState::None;
   SuperTy::clear();
 }
@@ -261,13 +261,13 @@ bool BottomUpRefCountState::handleGuaranteedUser(
 bool BottomUpRefCountState::isRefCountInstMatchedToTrackedInstruction(
     SILInstruction *RefCountInst) {
   // If we are not tracking any state transitions bail.
-  if (!Transition.hasValue())
+  if (!Transition.isValid())
     return false;
 
   // Otherwise, ask the transition state if this instruction causes a
   // transition that can be matched with the transition in order to eliminate
   // the transition.
-  if (!Transition->matchingInst(RefCountInst))
+  if (!Transition.matchingInst(RefCountInst))
     return false;
 
   return handleRefCountInstMatch(RefCountInst);
@@ -328,8 +328,8 @@ bool BottomUpRefCountState::merge(const BottomUpRefCountState &Other) {
     return false;
   }
 
-  if (!Transition.hasValue() || !Other.Transition.hasValue() ||
-      !Transition->merge(Other.Transition.getValue())) {
+  if (!Transition.isValid() || !Other.Transition.isValid() ||
+      !Transition.merge(Other.Transition)) {
     DEBUG(llvm::dbgs() << "            Failed merge!\n");
     clear();
     return false;
@@ -568,7 +568,7 @@ bool TopDownRefCountState::initWithMutatorInst(
 void TopDownRefCountState::initWithArg(SILArgument *Arg) {
   LatState = LatticeState::Incremented;
   Transition = RCStateTransition(Arg);
-  assert((*Transition).getKind() == RCStateTransitionKind::StrongEntrance &&
+  assert(Transition.getKind() == RCStateTransitionKind::StrongEntrance &&
          "Expected a strong entrance here");
   RCRoot = Arg;
   KnownSafe = false;
@@ -581,7 +581,7 @@ void TopDownRefCountState::initWithEntranceInst(
     ImmutablePointerSet<SILInstruction> *I, SILValue RCIdentity) {
   LatState = LatticeState::Incremented;
   Transition = RCStateTransition(I);
-  assert((*Transition).getKind() == RCStateTransitionKind::StrongEntrance &&
+  assert(Transition.getKind() == RCStateTransitionKind::StrongEntrance &&
          "Expected a strong entrance here");
   RCRoot = RCIdentity;
   KnownSafe = false;
@@ -590,7 +590,7 @@ void TopDownRefCountState::initWithEntranceInst(
 
 /// Uninitialize the current state.
 void TopDownRefCountState::clear() {
-  Transition = None;
+  Transition = RCStateTransition();
   LatState = LatticeState::None;
   SuperTy::clear();
 }
@@ -719,13 +719,13 @@ bool TopDownRefCountState::handleGuaranteedUser(
 bool TopDownRefCountState::isRefCountInstMatchedToTrackedInstruction(
     SILInstruction *RefCountInst) {
   // If we are not tracking any state transitions bail.
-  if (!Transition.hasValue())
+  if (!Transition.isValid())
     return false;
 
   // Otherwise, ask the transition state if this instruction causes a
   // transition that can be matched with the transition in order to eliminate
   // the transition.
-  if (!Transition->matchingInst(RefCountInst))
+  if (!Transition.matchingInst(RefCountInst))
     return false;
 
   return handleRefCountInstMatch(RefCountInst);
@@ -783,8 +783,8 @@ bool TopDownRefCountState::merge(const TopDownRefCountState &Other) {
     return false;
   }
 
-  if (!Transition.hasValue() || !Other.Transition.hasValue() ||
-      !Transition->merge(Other.Transition.getValue())) {
+  if (!Transition.isValid() || !Other.Transition.isValid() ||
+      !Transition.merge(Other.Transition)) {
     DEBUG(llvm::dbgs() << "            Failed merge!\n");
     clear();
     return false;
diff --git a/lib/SILOptimizer/ARC/RefCountState.h b/lib/SILOptimizer/ARC/RefCountState.h
@@ -14,6 +14,7 @@
 #define SWIFT_SILOPTIMIZER_PASSMANAGER_ARC_REFCOUNTSTATE_H
 
 #include "RCStateTransition.h"
+#include "swift/Basic/type_traits.h"
 #include "swift/Basic/Fallthrough.h"
 #include "swift/Basic/ImmutablePointerSet.h"
 #include "swift/SIL/SILInstruction.h"
@@ -22,7 +23,6 @@
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
 #include <algorithm>
-#include <type_traits>
 
 namespace swift {
 class AliasAnalysis;
@@ -37,17 +37,14 @@ namespace swift {
 /// A struct that abstracts over reference counts manipulated by strong_retain,
 /// retain_value, strong_release,
 class RefCountState {
-public:
-  using InstructionSet = llvm::SmallPtrSet<SILInstruction *, 1>;
-
 protected:
   /// Return the SILValue that represents the RCRoot that we are
   /// tracking.
   SILValue RCRoot;
 
   /// The last state transition that this RefCountState went through. None if we
   /// have not see any transition on this ref count yet.
-  llvm::Optional<RCStateTransition> Transition;
+  RCStateTransition Transition;
 
   /// Was the pointer we are tracking known incremented when we visited the
   /// current increment we are tracking? In that case we know that it is safe
@@ -67,8 +64,8 @@ class RefCountState {
   bool Partial = false;
 
 public:
-  RefCountState() {}
-  ~RefCountState() {}
+  RefCountState() = default;
+  ~RefCountState() = default;
   RefCountState(const RefCountState &) = default;
   RefCountState &operator=(const RefCountState &) = default;
   RefCountState(RefCountState &&) = default;
@@ -83,7 +80,7 @@ class RefCountState {
     bool Nested = isTrackingRefCount();
 
     Transition = RCStateTransition(I);
-    assert((*Transition).isMutator() && "Expected I to be a mutator!\n");
+    assert(Transition.isMutator() && "Expected I to be a mutator!\n");
 
     // Initialize KnownSafe to a conservative false value.
     KnownSafe = false;
@@ -105,31 +102,29 @@ class RefCountState {
   }
 
   /// Is this ref count initialized and tracking a ref count ptr.
-  bool isTrackingRefCount() const {
-    return Transition.hasValue();
-  }
+  bool isTrackingRefCount() const { return Transition.isValid(); }
 
   /// Are we tracking an instruction currently? This returns false when given an
   /// uninitialized ReferenceCountState.
   bool isTrackingRefCountInst() const {
-    return Transition.hasValue() && Transition->isMutator();
+    return Transition.isValid() && Transition.isMutator();
   }
 
   /// Are we tracking a source of ref counts? This currently means that we are
   /// tracking an argument that is @owned. In the future this will include
   /// return values of functions that are @owned.
   bool isTrackingRefCountSource() const {
-    return Transition.hasValue() && Transition->isEndPoint();
+    return Transition.isValid() && Transition.isEndPoint();
   }
 
   /// Return the increment we are tracking.
   RCStateTransition::mutator_range getInstructions() const {
-    return Transition->getMutators();
+    return Transition.getMutators();
   }
 
   /// Returns true if I is in the instructions we are tracking.
   bool containsInstruction(SILInstruction *I) const {
-    return Transition.hasValue() && Transition->containsMutator(I);
+    return Transition.isValid() && Transition.containsMutator(I);
   }
 
   /// Return the value with reference semantics that is the operand of our
@@ -200,7 +195,8 @@ class BottomUpRefCountState : public RefCountState {
   bool FoundNonARCUser = false;
 
 public:
-  BottomUpRefCountState() {}
+  BottomUpRefCountState() = default;
+  ~BottomUpRefCountState() = default;
   BottomUpRefCountState(const BottomUpRefCountState &) = default;
   BottomUpRefCountState &operator=(const BottomUpRefCountState &) = default;
   BottomUpRefCountState(BottomUpRefCountState &&) = default;
@@ -344,7 +340,8 @@ class TopDownRefCountState : public RefCountState {
   LatticeState LatState = LatticeState::None;
 
 public:
-  TopDownRefCountState() {}
+  TopDownRefCountState() = default;
+  ~TopDownRefCountState() = default;
   TopDownRefCountState(const TopDownRefCountState &) = default;
   TopDownRefCountState &operator=(const TopDownRefCountState &) = default;
   TopDownRefCountState(TopDownRefCountState &&) = default;
@@ -454,6 +451,12 @@ class TopDownRefCountState : public RefCountState {
   bool handleRefCountInstMatch(SILInstruction *RefCountInst);
 };
 
+// These static asserts are here for performance reasons.
+static_assert(IsTriviallyCopyable<BottomUpRefCountState>::value,
+              "All ref count states must be trivially copyable");
+static_assert(IsTriviallyCopyable<TopDownRefCountState>::value,
+              "All ref count states must be trivially copyable");
+
 } // end swift namespace
 
 namespace llvm {
