removed the registration logic from Initialization and Depth from Scope.

Swift SVN r4842

Author: lattner

lib/IRGen/Explosion.h

@@ -45,8 +45,6 @@ class ManagedValue {
     return getValue();
   }
   llvm::Value *getValue() const { return Value; }
-
-  bool hasCleanup() const { return false; }
 
   /// Forward this value, deactivating the cleanup and returning the
   /// underlying value.
@@ -160,11 +158,7 @@ class Explosion {
 
   /// The next N values are being ignored.  They are all unmanaged.
   void ignoreUnmanaged(unsigned n) {
-#ifndef NDEBUG
     assert(NextValue + n <= Values.size());
-    for (auto i = NextValue, e = NextValue + n; i != e; ++i)
-      assert(!Values[i].hasCleanup());
-#endif
     markClaimed(n);
   }
 
@@ -178,7 +172,6 @@ class Explosion {
   /// Claim a value which is known to have no management.
   llvm::Value *claimUnmanagedNext() {
     assert(NextValue < Values.size());
-    assert(!Values[NextValue].hasCleanup());
     return Values[NextValue++].getValue();
   }
 

lib/IRGen/GenFunc.cpp

@@ -1352,7 +1352,6 @@ void CallEmission::emitToExplosion(Explosion &out) {
 
     Initialization init;
     InitializedObject obj = init.getObjectForTemporary();
-    auto cleanup = init.registerObject(IGF, obj, NotOnHeap, substResultTI);
     Address temp = init.emitLocalAllocation(IGF, obj, NotOnHeap, substResultTI,
                                             "call.aggresult");
     emitToMemory(temp, substResultTI);
@@ -1363,10 +1362,10 @@ void CallEmission::emitToExplosion(Explosion &out) {
     if (substSchema.isSingleAggregate()) {
       auto substType = substSchema.begin()->getAggregateType()->getPointerTo();
       temp = IGF.Builder.CreateBitCast(temp, substType);
-      out.add(ManagedValue(temp.getAddress(), cleanup));
+      out.add(ManagedValue(temp.getAddress()));
 
-    // Otherwise, we need to load.  Do a take-load and deactivate the cleanup.
     } else {
+      // Otherwise, we need to load.
       substResultTI.loadAsTake(IGF, temp, out);
     }
     return;
@@ -1498,7 +1497,6 @@ void CallEmission::forceCallee() {
     // Allocate the temporary.
     Initialization init;
     auto object = init.getObjectForTemporary();
-    init.registerObjectWithoutDestroy(object);
     Address addr = init.emitLocalAllocation(IGF, object, NotOnHeap, substTI,
                                             "polymorphic-currying-temp")
       .getUnownedAddress();
@@ -1553,7 +1551,6 @@ void CallEmission::externalizeArgument(Explosion &out, Explosion &in,
   if (requiresExternalByvalArgument(IGF.IGM, ty)) {
     Initialization I;
     InitializedObject object = I.getObjectForTemporary();
-    I.registerObject(IGF, object, NotOnHeap, ti);
     OwnedAddress addr = ti.allocate(IGF,
                                     I,
                                     object,
@@ -1767,7 +1764,6 @@ void IRGenFunction::emitPrologue() {
       // work in the normal way.
       Initialization returnInit;
       auto returnObject = returnInit.getObjectForTemporary();
-      returnInit.registerObjectWithoutDestroy(returnObject);
 
       // Allocate the slot and leave its allocation cleanup hanging
       // around.

lib/IRGen/GenInit.cpp

@@ -35,33 +35,6 @@ using namespace swift;
 using namespace irgen;
 
 
-/// Register an object with the initialization process.
-CleanupsDepth Initialization::registerObject(IRGenFunction &IGF,
-                                             InitializedObject object,
-                                             OnHeap_t onHeap,
-                                             const TypeInfo &objectTI) {
-  // Create the appropriate destroy cleanup.
-  registerObject(object, CleanupsDepth::invalid());
-
-  return CleanupsDepth::invalid();
-}
-
-void Initialization::registerObjectWithoutDestroy(InitializedObject object) {
-  registerObject(object, CleanupsDepth::invalid());
-}
-
-/// Register an object with the initialization process.
-void Initialization::registerObject(InitializedObject object,
-                                    CleanupsDepth destroy) {
-  // The invariant is that the cleanup has to be an
-  // UnboundDestroy if it's valid.
-
-  ValueRecord record = {
-    CleanupsDepth::invalid(), destroy
-  };
-  Records.insert(std::make_pair(object.Opaque, record));
-}
-
 /// Emit a global variable.
 Address IRGenModule::emitGlobalVariable(VarDecl *var,
                                         const TypeInfo &type) {

lib/IRGen/GenInit.h

@@ -34,7 +34,6 @@
 #ifndef SWIFT_IRGEN_GENINIT_H
 #define SWIFT_IRGEN_GENINIT_H
 
-#include "llvm/ADT/DenseMap.h"
 #include "IRGenFunction.h"
 #include "swift/SIL/SILValue.h"
 
@@ -60,19 +59,10 @@ class InitializedObject {
 /// To use this, you need to:
 ///   - create an abstract Object for the object you'd like to initialize,
 ///     using one of the getObject* methods;
-///   - register that Object with the Initialization using one of the
-///     registerObject* methods;
 ///
 /// This class also provides several convenience methods for
 /// performing one or more stages of this process.
 class Initialization {
-  struct ValueRecord {
-    CleanupsDepth DeallocCleanup;
-    CleanupsDepth DestroyCleanup;
-  };
-
-  llvm::DenseMap<void *, ValueRecord> Records;
-
 public:
 
   /// Create an object reference for the given SIL value.
@@ -97,18 +87,6 @@ class Initialization {
                                    OnHeap_t onHeap, const TypeInfo &type,
                                    const Twine &name);
 
-  /// Add an object that is going to be initialized; use the
-  /// appropriate destroy cleanup for the given type.
-  CleanupsDepth registerObject(IRGenFunction &IGF, InitializedObject object,
-                               OnHeap_t onHeap, const TypeInfo &objectTI);
-
-  /// Add an object that is going to be initialized, but which does not
-  /// need a destroy cleanup.
-  void registerObjectWithoutDestroy(InitializedObject object);
-
-private:
-  /// Add an object that is going to be initialized.
-  void registerObject(InitializedObject object, CleanupsDepth destroy);
 };
 
 } // end namespace irgen

lib/IRGen/GenPoly.cpp

@@ -404,7 +404,6 @@ namespace {
     void initIntoTemporary(const TypeInfo &substTI) {
       Initialization init;
       auto object = init.getObjectForTemporary();
-      auto cleanup = init.registerObject(IGF, object, NotOnHeap, substTI);
       auto addr = init.emitLocalAllocation(IGF, object, NotOnHeap, substTI,
                                            "substitution.temp").getAddress();
 
@@ -415,7 +414,7 @@ namespace {
       addr = IGF.Builder.CreateBitCast(addr, IGF.IGM.OpaquePtrTy, "temp.cast");
 
       // Add that to the output explosion.
-      Out.add(ManagedValue(addr.getAddress(), cleanup));
+      Out.add(ManagedValue(addr.getAddress()));
     }
 
     void visitArrayType(ArrayType *origTy, ArrayType *substTy) {

lib/IRGen/IRGenSIL.cpp

@@ -1138,7 +1138,6 @@ void IRGenSILFunction::visitAllocVarInst(swift::AllocVarInst *i) {
   Initialization init;
   SILValue v(i, 0);
   InitializedObject initVar = init.getObjectForValue(v);
-  init.registerObjectWithoutDestroy(initVar);
 
   OnHeap_t isOnHeap = NotOnHeap;
   switch (i->getAllocKind()) {
@@ -1186,7 +1185,6 @@ void IRGenSILFunction::visitAllocBoxInst(swift::AllocBoxInst *i) {
   const TypeInfo &type = getFragileTypeInfo(i->getElementType());
   Initialization init;
   InitializedObject initBox = init.getObjectForValue(boxValue);
-  init.registerObjectWithoutDestroy(initBox);
   OwnedAddress addr = type.allocate(*this,
                                     init,
                                     initBox,

lib/IRGen/IndirectTypeInfo.h

@@ -58,15 +58,13 @@ class IndirectTypeInfo : public Base {
     // Create a temporary.
     Initialization init;
     auto temp = init.getObjectForTemporary();
-    auto cleanup = init.registerObject(IGF, temp, NotOnHeap, *this);
     Address dest = asDerived().Derived::allocate(IGF, init, temp, NotOnHeap,
                                                  "temporary.forLoad");
 
     // Initialize it with a copy of the source.
     asDerived().Derived::initializeWithCopy(IGF, dest, src);
 
-    // Enter a cleanup for the temporary.
-    out.add(ManagedValue(dest.getAddress(), cleanup));
+    out.add(ManagedValue(dest.getAddress()));
   }
 
   void loadUnmanaged(IRGenFunction &IGF, Address src, Explosion &out) const {
@@ -78,8 +76,6 @@ class IndirectTypeInfo : public Base {
 
     // Initialize it with a copy of the source.
     asDerived().Derived::initializeWithCopy(IGF, dest, src);
-    
-    // Enter a cleanup for the temporary.
     out.addUnmanaged(dest.getAddress());
   }
 
@@ -88,15 +84,14 @@ class IndirectTypeInfo : public Base {
     // to destroy that.
     Initialization init;
     auto temp = init.getObjectForTemporary();
-    auto cleanup = init.registerObject(IGF, temp, NotOnHeap, *this);
     Address dest = asDerived().Derived::allocate(IGF, init, temp, NotOnHeap,
                                                  "temporary.forLoad");
 
     // Initialize it with a take of the source.
     asDerived().Derived::initializeWithTake(IGF, dest, src);
 
     // Enter a cleanup for the temporary.
-    out.add(ManagedValue(dest.getAddress(), cleanup));
+    out.add(ManagedValue(dest.getAddress()));
   }
 
   void assign(IRGenFunction &IGF, Explosion &in, Address dest) const {

lib/IRGen/Scope.h

@@ -26,22 +26,24 @@ namespace irgen {
 /// statement) has been entered.
 class Scope {
   IRGenFunction &IGF;
-  CleanupsDepth Depth;
   IRGenFunction::LocalTypeDataDepth SavedLocalTypeDataDepth;
-
+  bool Popped;
 public:
   explicit Scope(IRGenFunction &IGF)
-    : IGF(IGF),  SavedLocalTypeDataDepth(IGF.ScopedLocalTypeData.size()) {
+    : IGF(IGF), SavedLocalTypeDataDepth(IGF.ScopedLocalTypeData.size()) {
+      Popped = false;
   }
 
   void pop() {
-    assert(Depth.isValid() && "popping a scope twice!");
+    assert(!Popped);
     assert(IGF.ScopedLocalTypeData.size() >= SavedLocalTypeDataDepth);
     IGF.endLocalTypeDataScope(SavedLocalTypeDataDepth);
+    Popped = true;
   }
 
   ~Scope() {
-    if (Depth.isValid()) pop();
+    if (!Popped)
+      pop();
   }
 };