remove the cleanups list from CallEmission and ManagedValue, along with the machinery for adding Cleanups.

Swift SVN r4840

Author: lattner

lib/IRGen/CallEmission.h

@@ -38,9 +38,6 @@ class CallEmission {
   /// The builtin/special arguments to pass to the call.
   llvm::SmallVector<llvm::Value*, 8> Args;
 
-  /// The cleanups to deactivate when we make a call.
-  llvm::SmallVector<CleanupsDepth, 8> Cleanups;
-
   /// The function we're going to call.
   Callee CurCallee;
 

lib/IRGen/Cleanup.h

@@ -30,11 +30,9 @@ class Cleanup {
   unsigned AllocatedSize;
   unsigned State : 2;
 
-  friend Cleanup &IRGenFunction::initCleanup(Cleanup &, size_t, CleanupState);
-protected:
+ protected:
   Cleanup() {}
   virtual ~Cleanup() {}
-  // The fields are initialized by IRGenFunction::initCleanup.
 
 public:
   /// Return the allocated size of this object.  This is required by

lib/IRGen/Explosion.h

@@ -33,35 +33,24 @@ namespace irgen {
 /// cleanup.
 class ManagedValue {
   llvm::Value *Value;
-  CleanupsDepth Cleanup;
 
 public:
   ManagedValue() = default;
   explicit ManagedValue(llvm::Value *value)
-    : Value(value), Cleanup(CleanupsDepth::invalid()) {}
+    : Value(value) {}
   ManagedValue(llvm::Value *value, CleanupsDepth cleanup)
-    : Value(value), Cleanup(cleanup) {}
+    : Value(value) {}
 
   llvm::Value *getUnmanagedValue() const {
-    assert(!hasCleanup());
     return getValue();
   }
   llvm::Value *getValue() const { return Value; }
 
-  bool hasCleanup() const { return Cleanup.isValid(); }
-  CleanupsDepth getCleanup() const { return Cleanup; }
-
+  bool hasCleanup() const { return false; }
+ 
   /// Forward this value, deactivating the cleanup and returning the
   /// underlying value.
   llvm::Value *forward(IRGenFunction &IGF) {
-    if (hasCleanup())
-      IGF.setCleanupState(getCleanup(), CleanupState::Dead);
-    return getValue();
-  }
-
-  /// Split this value into its underlying value and, if present, its cleanup.
-  llvm::Value *split(llvm::SmallVectorImpl<CleanupsDepth> &cleanups) {
-    if (hasCleanup()) cleanups.push_back(getCleanup());
     return getValue();
   }
 };

lib/IRGen/GenControl.cpp

@@ -82,47 +82,5 @@ llvm::CallSite IRGenFunction::emitInvoke(llvm::CallingConv::ID convention,
 //****************************************************************************//
 
 
-
-/// Remove all the dead cleanups on the top of the cleanup stack.
-static void popAndEmitTopDeadCleanups(IRGenFunction &IGF,
-                                      DiverseStackImpl<Cleanup> &stack,
-                                      CleanupsDepth end) {
-  stack.checkIterator(end);
-
-  while (stack.stable_begin() != end && stack.begin()->isDead()) {
-    assert(!stack.empty());
-
-    // We might get better results popping them all at once.
-    stack.pop();
-    stack.checkIterator(end);
-  }
-}
-
-/// Leave a scope, with all its cleanups.
-void IRGenFunction::endScope(CleanupsDepth depth) {
-  Cleanups.checkIterator(depth);
-
-  popAndEmitTopDeadCleanups(*this, Cleanups, InnermostScope);
-}
-
-
-/// Initialize a just-pushed cleanup.
-Cleanup &IRGenFunction::initCleanup(Cleanup &cleanup, size_t allocSize,
-                                    CleanupState state) {
-  cleanup.AllocatedSize = allocSize;
-  cleanup.State = unsigned(state);
-
-  return cleanup;
-}
-
-/// Change the state of a cleanup.
-void IRGenFunction::setCleanupState(CleanupsDepth depth,
-                                    CleanupState newState) {
-}
-
-void IRGenFunction::setCleanupState(Cleanup &cleanup, CleanupState newState) {
-  cleanup.setState(newState);
-}
-
 // Anchor the Cleanup v-table in this translation unit.
 void Cleanup::_anchor() {}

lib/IRGen/GenFunc.cpp

@@ -1254,11 +1254,6 @@ llvm::CallSite CallEmission::emitCallSite(bool hasIndirectResult) {
   assert(!EmittedCall);
   EmittedCall = true;
 
-  // Deactivate all the cleanups.
-  for (auto cleanup : Cleanups)
-    IGF.setCleanupState(cleanup, CleanupState::Dead);
-  Cleanups.clear();
-
   // Determine the calling convention.
   // FIXME: collect attributes in the CallEmission.
   auto cc = expandAbstractCC(IGF.IGM, getCallee().getConvention());
@@ -1374,8 +1369,6 @@ void CallEmission::emitToExplosion(Explosion &out) {
     // Otherwise, we need to load.  Do a take-load and deactivate the cleanup.
     } else {
       substResultTI.loadAsTake(IGF, temp, out);
-      if (cleanup.isValid())
-        IGF.setCleanupState(cleanup, CleanupState::Dead);
     }
     return;
   }
@@ -1419,7 +1412,6 @@ void CallEmission::emitToExplosion(Explosion &out) {
 CallEmission::CallEmission(CallEmission &&other)
   : IGF(other.IGF),
     Args(std::move(other.Args)),
-    Cleanups(std::move(other.Cleanups)),
     CurCallee(std::move(other.CurCallee)),
     CurOrigType(other.CurOrigType),
     RemainingArgsForCallee(other.RemainingArgsForCallee),
@@ -1458,13 +1450,10 @@ void CallEmission::setFromCallee() {
   Args.set_size(numArgs);
   LastArgWritten = numArgs;
 
-  // We should not have any cleanups at this point.
-  assert(Cleanups.empty());
-
   // Add the data pointer if we have one.
   if (CurCallee.hasDataPointer()) {
     assert(LastArgWritten > 0);
-    Args[--LastArgWritten] = CurCallee.getDataPointer(IGF).split(Cleanups);
+    Args[--LastArgWritten] = CurCallee.getDataPointer(IGF).getValue();
   }
 }
 
@@ -1645,7 +1634,7 @@ void CallEmission::addArg(Explosion &arg) {
     auto value = values[i];
     // The default rule is that arguments are consumed, in which case
     // we need to deactivate cleanups when making the call.
-    *argIterator++ = value.split(Cleanups);
+    *argIterator++ = value.getValue();
   }
 
   LastArgWritten = newLastArgWritten;
@@ -1862,11 +1851,6 @@ bool IRGenFunction::emitBranchToReturnBB() {
 
 /// Emit the epilogue for the function.
 void IRGenFunction::emitEpilogue() {
-  // Leave the cleanups created for the parameters if we've got a full
-  // prologue.
-  if (CurPrologue != Prologue::Bare)
-    endScope(Cleanups.stable_end());
-
   // Destroy the alloca insertion point.
   AllocaIP->eraseFromParent();
 

lib/IRGen/GenInit.cpp

@@ -160,22 +160,10 @@ OwnedAddress FixedTypeInfo::allocate(IRGenFunction &IGF, Initialization &init,
   return addr;
 }
 
-static void maybeSetCleanupState(IRGenFunction &IGF,
-                                 CleanupsDepth maybeCleanup,
-                                 CleanupState newState) {
-  if (maybeCleanup.isValid())
-    IGF.setCleanupState(maybeCleanup, newState);
-}
 
 /// Mark that a value has reached its initialization point.
 void Initialization::markInitialized(IRGenFunction &IGF,
                                      InitializedObject object) {
   auto it = Records.find(object.Opaque);
   assert(it != Records.end());
-
-  // Deactivate the dealloc cleanup.
-  maybeSetCleanupState(IGF, it->second.DeallocCleanup, CleanupState::Dead);
-
-  // Activate the destroy cleanup.
-  maybeSetCleanupState(IGF, it->second.DestroyCleanup, CleanupState::Active);
 }

lib/IRGen/GenPoly.cpp

@@ -392,7 +392,7 @@ namespace {
         auto addr = IGF.Builder.CreateBitCast(inValue.getValue(),
                                               IGF.IGM.OpaquePtrTy,
                                               "substitution.reinterpret");
-        Out.add(ManagedValue(addr, inValue.getCleanup()));
+        Out.add(ManagedValue(addr));
         return;
       }
 
@@ -470,7 +470,7 @@ namespace {
       auto origValue =
         IGF.Builder.CreateBitCast(substValue, origPtrTy,
                                   substValue->getName() + ".reinterpret");
-      Out.add(ManagedValue(origValue, substMV.getCleanup()));
+      Out.add(ManagedValue(origValue));
     }
 
     void visitMetaTypeType(MetaTypeType *origTy, MetaTypeType *substTy) {
@@ -554,15 +554,13 @@ namespace {
       // If the substituted type is still a single indirect value,
       // just pass it on without reinterpretation.
       if (IGF.IGM.isSingleIndirectValue(substTy, In.getKind())) {
-        Out.add(ManagedValue(inAddr, inValue.getCleanup()));
+        Out.add(ManagedValue(inAddr));
         return;
       }
 
       // Otherwise, load as a take and then kill the cleanup attached
       // to the archetype value.
       substTI.loadAsTake(IGF, substTI.getAddressForPointer(inAddr), Out);
-      if (inValue.hasCleanup())
-        IGF.setCleanupState(inValue.getCleanup(), CleanupState::Dead);
     }
 
     void visitArrayType(ArrayType *origTy, ArrayType *substTy) {
@@ -616,7 +614,7 @@ namespace {
       auto substValue =
         IGF.Builder.CreateBitCast(origValue, substPtrTy,
                                   origValue->getName() + ".reinterpret");
-      Out.add(ManagedValue(substValue, origMV.getCleanup()));
+      Out.add(ManagedValue(substValue));
     }
 
     void visitMetaTypeType(MetaTypeType *origTy, MetaTypeType *substTy) {

lib/IRGen/IRGenFunction.h

@@ -137,66 +137,11 @@ class IRGenFunction {
 //--- Control flow -------------------------------------------------------------
 public:
 
-  /// Push a new cleanup in the current scope.
-  template <class T, class... A>
-  T &pushCleanup(A &&... args) {
-    return pushCleanupInState<T, A...>(CleanupState::Active,
-                                       ::std::forward<A>(args)...);
-  }
-
-  /// Push a new cleanup in the current scope.
-  template <class T, class... A>
-  T &pushCleanupInState(CleanupState state, A &&... args) {
-    assert(state != CleanupState::Dead);
-
-#ifndef NDEBUG
-    CleanupsDepth oldTop = Cleanups.stable_begin();
-#endif
-
-    T &cleanup = Cleanups.push<T, A...>(::std::forward<A>(args)...);
-    T &result = static_cast<T&>(initCleanup(cleanup, sizeof(T), state));
-
-#ifndef NDEBUG
-    auto newTop = Cleanups.begin(); ++newTop;
-    assert(newTop == Cleanups.find(oldTop));
-#endif
-    return result;
-  }
-
-  /// Push a new cleanup which is expected to be destroyed at the end
-  /// of the current full-expression.
-  ///
-  /// The relevant property here is that full-expression cleanups may
-  /// not be dominated by the locations in which they're active in a
-  /// full-expression expression.
-  template <class T, class... A>
-  T &pushFullExprCleanup(A &&... args) {
-    assert(!isConditionallyEvaluated());
-    return pushCleanup<T, A...>(::std::forward<A>(args)...);
-  }
-
-  template <class T, class... A>
-  T &pushFullExprCleanupInState(CleanupState state, A &&... args) {
-    assert(!isConditionallyEvaluated());
-    return pushCleanupInState<T, A...>(state, ::std::forward<A>(args)...);
-  }
-
   /// Return a stable reference to the current cleanup.
   CleanupsDepth getCleanupsDepth() const {
     return Cleanups.stable_begin();
   }
 
-  /// Set the state of the cleanup at the given depth.
-  /// The transition must be non-trivial and legal.
-  void setCleanupState(CleanupsDepth depth, CleanupState state);
-
-  Cleanup &findCleanup(CleanupsDepth depth) {
-    assert(depth != Cleanups.stable_end());
-    return *Cleanups.find(depth);
-  }
-
-  void endScope(CleanupsDepth depth);
- 
   void enterDestroyCleanup(Address addr, const TypeInfo &addrTI,
                            Explosion &out);
 
@@ -219,10 +164,7 @@ class IRGenFunction {
   llvm::Instruction *JumpDestSlot;
   CleanupsDepth InnermostScope;
 
-  friend class Cleanup; // just so that it can befriend initCleanup
   friend class Scope;
-  Cleanup &initCleanup(Cleanup &cleanup, size_t allocSize, CleanupState state);
-  void setCleanupState(Cleanup &cleanup, CleanupState state);
 
 //--- Function prologue and epilogue -------------------------------------------
 public:

lib/IRGen/Scope.h

@@ -36,7 +36,6 @@ class Scope {
     assert(IGF.InnermostScope == Depth && "popping scopes out of order");
 
     IGF.InnermostScope = SavedInnermostScope;
-    IGF.endScope(Depth);
     IGF.Cleanups.checkIterator(IGF.InnermostScope);
 
     assert(IGF.ScopedLocalTypeData.size() >= SavedLocalTypeDataDepth);