[arc] Make all *RefCountStates and RCStateTransition trivially destructable and constructable.

gottesmm · gottesmm · commit d55ebaec423a · 2016-02-17T16:06:32.000-08:00
Tested via static assert.

There is no reason for these data structures to not have these properties.
Adding these properties will improve the compile time efficiency of ARC by
allowing for cheaper copying and 0 cost destruction.
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 {
