SILGen: Combine related addressable buffer bookkeeping types into one place.

There's no need for two separate types here. Fully separate the addressable buffer
tracking from VarLocs as well, in order to set up for a fix to addressable references
to `if let` and `guard let` bindings.

Author: jckarter

lib/SILGen/SILGenDecl.cpp

@@ -682,7 +682,7 @@ namespace {
 
 static void deallocateAddressable(SILGenFunction &SGF,
                 SILLocation l,
-                const SILGenFunction::VarLoc::AddressableBuffer::State &state) {
+                const SILGenFunction::AddressableBuffer::State &state) {
   SGF.B.createEndBorrow(l, state.storeBorrow);
   SGF.B.createDeallocStack(l, state.allocStack);
   if (state.reabstraction
@@ -704,10 +704,6 @@ class DeallocateLocalVariableAddressableBuffer : public Cleanup {
     if (!addressableBuffer) {
       return;
     }
-    auto found = SGF.VarLocs.find(vd);
-    if (found == SGF.VarLocs.end()) {
-      return;
-    }
 
     if (auto *state = addressableBuffer->getState()) {
       // The addressable buffer was forced, so clean it up now.
@@ -2243,7 +2239,7 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
 void
 SILGenFunction::enterLocalVariableAddressableBufferScope(VarDecl *decl) {
   auto marker = B.createTuple(decl, {});
-  AddressableBuffers[decl] = marker;
+  AddressableBuffers[decl].insertPoint = marker;
   Cleanups.pushCleanup<DeallocateLocalVariableAddressableBuffer>(decl);
 }
 
@@ -2296,27 +2292,12 @@ SILGenFunction::getLocalVariableAddressableBuffer(VarDecl *decl,
   SILValue reabstraction, allocStack, storeBorrow;
   {
     SavedInsertionPointRAII save(B);
-    SILInstruction *insertPoint = nullptr;
-    // Look through bindings that might alias the original addressable buffer
-    // (such as case block variables, which use an alias variable to represent the
-    // incoming value from all of the case label patterns).
-    VarDecl *origDecl = decl;
-    do {
-      auto bufferIter = AddressableBuffers.find(origDecl);
-      ASSERT(bufferIter != AddressableBuffers.end()
-             && "local variable didn't have an addressability scope set");
-
-      insertPoint = bufferIter->second.getInsertPoint();
-      if (insertPoint) {
-        break;
-      }
+    auto *addressableBuffer = getAddressableBufferInfo(decl);
 
-      origDecl = bufferIter->second.getOriginalForAlias();
-      ASSERT(origDecl && "no insert point or alias for addressable declaration!");
-    } while (true);
-      
-    assert(insertPoint && "didn't find an insertion point for the addressable buffer");
-    B.setInsertionPoint(insertPoint);
+    assert(addressableBuffer
+           && addressableBuffer->insertPoint
+           && "didn't find an insertion point for the addressable buffer");
+    B.setInsertionPoint(addressableBuffer->insertPoint);
     auto allocStackTy = fullyAbstractedTy;
     if (value->getType().isMoveOnlyWrapped()) {
       allocStackTy = allocStackTy.addingMoveOnlyWrapper();
@@ -2366,7 +2347,7 @@ SILGenFunction::getLocalVariableAddressableBuffer(VarDecl *decl,
   // Record the addressable representation.
   auto *addressableBuffer = getAddressableBufferInfo(decl);
   auto *newState
-    = new VarLoc::AddressableBuffer::State(reabstraction, allocStack, storeBorrow);
+    = new AddressableBuffer::State(reabstraction, allocStack, storeBorrow);
   addressableBuffer->stateOrAlias = newState;
 
   // Emit cleanups on any paths where we previously would have cleaned up
@@ -2415,7 +2396,10 @@ void BlackHoleInitialization::copyOrInitValueInto(SILGenFunction &SGF, SILLocati
   SGF.B.createIgnoredUse(loc, value.getValue());
 }
 
-SILGenFunction::VarLoc::AddressableBuffer::~AddressableBuffer() {
+SILGenFunction::AddressableBuffer::~AddressableBuffer() {
+  if (insertPoint) {
+    insertPoint->eraseFromParent();
+  }
   for (auto cleanupPoint : cleanupPoints) {
     cleanupPoint->eraseFromParent();
   }

lib/SILGen/SILGenFunction.cpp

@@ -2005,19 +2005,16 @@ void SILGenFunction::emitAssignOrInit(SILLocation loc, ManagedValue selfValue,
                        AssignOrInitInst::Unknown);
 }
 
-SILGenFunction::VarLoc::AddressableBuffer *
+SILGenFunction::AddressableBuffer *
 SILGenFunction::getAddressableBufferInfo(ValueDecl *vd) {
   do {
-    auto found = VarLocs.find(vd);
-    if (found == VarLocs.end()) {
-      return nullptr;
-    }
+    auto &found = AddressableBuffers[vd];
 
-    if (auto orig = found->second.addressableBuffer.stateOrAlias
+    if (auto orig = found.stateOrAlias
                       .dyn_cast<VarDecl*>()) {
       vd = orig;
       continue;
     }
-    return &found->second.addressableBuffer;
+    return &found;
   } while (true);
 }

lib/SILGen/SILGenFunction.h

@@ -478,67 +478,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
     /// or `Unknown` if it's known to be immutable.
     SILAccessEnforcement access;
 
-    /// A structure used for bookkeeping the on-demand formation and cleanup
-    /// of an addressable representation for an immutable value binding.
-    struct AddressableBuffer {
-      struct State {
-        // If the value needs to be reabstracted to provide an addressable
-        // representation, this SILValue owns the reabstracted representation.
-        SILValue reabstraction = SILValue();
-        // The stack allocation for the addressable representation.
-        SILValue allocStack = SILValue();
-        // The initiation of the in-memory borrow.
-        SILValue storeBorrow = SILValue();
-        
-        State(SILValue reabstraction,
-              SILValue allocStack,
-              SILValue storeBorrow)
-          : reabstraction(reabstraction), allocStack(allocStack),
-            storeBorrow(storeBorrow)
-        {}
-      };
-      
-      llvm::PointerUnion<State *, VarDecl*> stateOrAlias = (State*)nullptr;
-
-      // If the variable cleanup is triggered before the addressable
-      // representation is demanded, but the addressable representation
-      // gets demanded later, we save the insertion points where the
-      // representation would be cleaned up so we can backfill them.
-      llvm::SmallVector<SILInstruction*, 1> cleanupPoints;
-      
-      AddressableBuffer() = default;
-
-      AddressableBuffer(VarDecl *original)
-        : stateOrAlias(original)
-      {
-      }
-      
-      AddressableBuffer(AddressableBuffer &&other)
-        : stateOrAlias(other.stateOrAlias)
-      {
-        other.stateOrAlias = (State*)nullptr;
-        cleanupPoints.swap(other.cleanupPoints);
-      }
-      
-      AddressableBuffer &operator=(AddressableBuffer &&other) {
-        if (auto state = stateOrAlias.dyn_cast<State*>()) {
-          delete state;
-        }
-        stateOrAlias = other.stateOrAlias;
-        cleanupPoints.swap(other.cleanupPoints);
-        return *this;
-      }
-
-      State *getState() {
-        ASSERT(!isa<VarDecl *>(stateOrAlias) &&
-               "must get state from original AddressableBuffer");
-        return stateOrAlias.dyn_cast<State*>();
-      }
-      
-      ~AddressableBuffer();
-    };
-    AddressableBuffer addressableBuffer;
-    
     VarLoc() = default;
 
     VarLoc(SILValue value, SILAccessEnforcement access,
@@ -552,55 +491,71 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// a local variable.
   llvm::DenseMap<ValueDecl*, VarLoc> VarLocs;
 
-  VarLoc::AddressableBuffer *getAddressableBufferInfo(ValueDecl *vd);
-  
-  // Represents an addressable buffer that has been allocated but not yet used.
-  struct PreparedAddressableBuffer {
-    llvm::PointerUnion<SILInstruction *, VarDecl *> insertPointOrAlias
-      = (SILInstruction*)nullptr;
+  /// A structure used for bookkeeping the on-demand formation and cleanup
+  /// of an addressable representation for an immutable value binding.
+  struct AddressableBuffer {
+    struct State {
+      // If the value needs to be reabstracted to provide an addressable
+      // representation, this SILValue owns the reabstracted representation.
+      SILValue reabstraction = SILValue();
+      // The stack allocation for the addressable representation.
+      SILValue allocStack = SILValue();
+      // The initiation of the in-memory borrow.
+      SILValue storeBorrow = SILValue();
+      
+      State(SILValue reabstraction,
+            SILValue allocStack,
+            SILValue storeBorrow)
+        : reabstraction(reabstraction), allocStack(allocStack),
+          storeBorrow(storeBorrow)
+      {}
+    };
 
-    PreparedAddressableBuffer() = default;
+    llvm::PointerUnion<State *, VarDecl*> stateOrAlias = (State*)nullptr;
+
+    // The point at which the buffer will be inserted.
+    SILInstruction *insertPoint = nullptr;
 
-    PreparedAddressableBuffer(SILInstruction *insertPoint)
-      : insertPointOrAlias(insertPoint)
-    {
-      ASSERT(insertPoint && "null insertion point provided");
-    }
+    // If the variable cleanup is triggered before the addressable
+    // representation is demanded, but the addressable representation
+    // gets demanded later, we save the insertion points where the
+    // representation would be cleaned up so we can backfill them.
+    llvm::SmallVector<SILInstruction*, 1> cleanupPoints;
+    
+    AddressableBuffer() = default;
 
-    PreparedAddressableBuffer(VarDecl *alias)
-      : insertPointOrAlias(alias)
+    AddressableBuffer(VarDecl *original)
+      : stateOrAlias(original)
     {
-      ASSERT(alias && "null alias provided");
     }
 
-    PreparedAddressableBuffer(PreparedAddressableBuffer &&other)
-      : insertPointOrAlias(other.insertPointOrAlias)
+    AddressableBuffer(AddressableBuffer &&other)
+      : stateOrAlias(other.stateOrAlias)
     {
-      other.insertPointOrAlias = (SILInstruction*)nullptr;
+      other.stateOrAlias = (State*)nullptr;
+      cleanupPoints.swap(other.cleanupPoints);
     }
 
-    PreparedAddressableBuffer &operator=(PreparedAddressableBuffer &&other) {
-      insertPointOrAlias = other.insertPointOrAlias;
-      other.insertPointOrAlias = nullptr;
+    AddressableBuffer &operator=(AddressableBuffer &&other) {
+      if (auto state = stateOrAlias.dyn_cast<State*>()) {
+        delete state;
+      }
+      stateOrAlias = other.stateOrAlias;
+      cleanupPoints.swap(other.cleanupPoints);
       return *this;
     }
 
-    SILInstruction *getInsertPoint() const {
-      return insertPointOrAlias.dyn_cast<SILInstruction*>();
+    State *getState() {
+      ASSERT(!isa<VarDecl *>(stateOrAlias) &&
+             "must get state from original AddressableBuffer");
+      return stateOrAlias.dyn_cast<State*>();
     }
 
-    VarDecl *getOriginalForAlias() const {
-      return insertPointOrAlias.dyn_cast<VarDecl*>();
-    }
-
-    ~PreparedAddressableBuffer() {
-      if (auto insertPoint = getInsertPoint()) {
-        // Remove the insertion point if it went unused.
-        insertPoint->eraseFromParent();
-      }
-    }
+    ~AddressableBuffer();
   };
-  llvm::DenseMap<VarDecl *, PreparedAddressableBuffer> AddressableBuffers;
+  llvm::DenseMap<ValueDecl *, AddressableBuffer> AddressableBuffers;
+    
+  AddressableBuffer *getAddressableBufferInfo(ValueDecl *vd);
 
   /// Establish the scope for the addressable buffer that might be allocated
   /// for a local variable binding.

lib/SILGen/SILGenPattern.cpp

@@ -3173,8 +3173,6 @@ static void switchCaseStmtSuccessCallback(SILGenFunction &SGF,
           expectedLoc = SILGenFunction::VarLoc(vdLoc->second.value,
                                                vdLoc->second.access,
                                                vdLoc->second.box);
-          expectedLoc.addressableBuffer = vd;
-          // Alias the addressable buffer for the two variables.
           SGF.AddressableBuffers[expected] = vd;
 
           // Emit a debug description for the variable, nested within a scope