Merge pull request #79963 from gottesmm/pr-6e79b08bb62307778a04913d3c02b8ed620f61bc

Revert "SILGen: Emit an addressable representation for immutable bindings on demand."

Author: gottesmm

include/swift/AST/Types.h

@@ -4334,7 +4334,9 @@ inline bool isConsumedParameterInCaller(ParameterConvention conv) {
   return isConsumedParameter<false>(conv);
 }
 
-/// Returns true if conv is a guaranteed parameter.
+/// Returns true if conv is a guaranteed parameter. This may look unnecessary
+/// but this will allow code to generalize to handle Indirect_Guaranteed
+/// parameters when they are added.
 template <bool InCallee>
 bool isGuaranteedParameter(ParameterConvention conv) {
   switch (conv) {

lib/SIL/IR/AbstractionPattern.cpp

@@ -1679,7 +1679,9 @@ AbstractionPattern::isFunctionParamAddressable(TypeConverter &TC,
     auto type = getType();
 
     if (type->isTypeParameter() || type->is<ArchetypeType>()) {
-      return false;
+      // If the function abstraction pattern is completely opaque, assume we
+      // may need to preserve the address for dependencies.
+      return true;    
     }
 
     auto fnTy = cast<AnyFunctionType>(getType());

lib/SILGen/SILGenApply.cpp

@@ -3462,9 +3462,11 @@ SILGenFunction::tryEmitAddressableParameterAsAddress(ArgumentSource &&arg,
       expr = le->getSubExpr();
     }
     if (auto dre = dyn_cast<DeclRefExpr>(expr)) {
-      if (auto param = dyn_cast<VarDecl>(dre->getDecl())) {
-        if (auto addr = getLocalVariableAddressableBuffer(param, expr,
-                                                          ownership)) {
+      if (auto param = dyn_cast<ParamDecl>(dre->getDecl())) {
+        if (VarLocs.count(param)
+            && VarLocs[param].addressable
+            && param->getValueOwnership() == ownership) {
+          auto addr = VarLocs[param].value;
           return ManagedValue::forBorrowedAddressRValue(addr);
         }
       }
@@ -3575,20 +3577,12 @@ class ArgEmitter {
   void emit(ArgumentSource &&arg, AbstractionPattern origParamType,
             bool isAddressable,
             std::optional<AnyFunctionType::Param> origParam = std::nullopt) {
-    if (isAddressable) {
+    if (isAddressable && origParam) {
       // If the function takes an addressable parameter, and its argument is
       // a reference to an addressable declaration with compatible ownership,
       // forward the address along in-place.
-      ValueOwnership paramOwnership;
-      if (isGuaranteedParameterInCaller(ParamInfos.front().getConvention())) {
-        paramOwnership = ValueOwnership::Shared;
-      } else if (isMutatingParameter(ParamInfos.front().getConvention())) {
-        paramOwnership = ValueOwnership::InOut;
-      } else {
-        paramOwnership = ValueOwnership::Owned;      
-      }
       if (auto addr = SGF.tryEmitAddressableParameterAsAddress(std::move(arg),
-                                                              paramOwnership)) {
+                                             origParam->getValueOwnership())) {
         claimNextParameters(1);
         Args.push_back(addr);
         return;

lib/SILGen/SILGenBuilder.cpp

@@ -1081,18 +1081,6 @@ class EndAccessCleanup final : public Cleanup {
 };
 }
 
-SILValue
-SILGenBuilder::emitBeginAccess(SILLocation loc,
-                               SILValue address,
-                               SILAccessKind kind,
-                               SILAccessEnforcement enforcement) {
-  auto access = createBeginAccess(loc, address,
-                                  kind, enforcement,
-                                  /*no nested conflict*/ false, false);
-  SGF.Cleanups.pushCleanup<EndAccessCleanup>(access);
-  return access;
-}
-
 ManagedValue
 SILGenBuilder::createOpaqueBorrowBeginAccess(SILLocation loc,
                                              ManagedValue address) {

lib/SILGen/SILGenBuilder.h

@@ -477,10 +477,6 @@ class SILGenBuilder : public SILBuilder {
                                     ManagedValue base,
                                     MarkDependenceKind dependencekind);
 
-  SILValue emitBeginAccess(SILLocation loc, SILValue address,
-                           SILAccessKind kind,
-                           SILAccessEnforcement enforcement);
-
   ManagedValue createOpaqueBorrowBeginAccess(SILLocation loc,
                                              ManagedValue address);
   ManagedValue createOpaqueConsumeBeginAccess(SILLocation loc,

lib/SILGen/SILGenConstructor.cpp

@@ -1173,8 +1173,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
             MarkUnresolvedNonCopyableValueInst::CheckKind::
                 ConsumableAndAssignable);
       }
-      VarLocs[selfDecl] = VarLoc(selfArg.getValue(),
-                                 SILAccessEnforcement::Static);
+      VarLocs[selfDecl] = VarLoc::get(selfArg.getValue());
     }
   }
 
@@ -1697,7 +1696,7 @@ void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
   selfArg = B.createMarkUninitialized(selfDecl, selfArg,
                                       MarkUninitializedInst::RootSelf);
   assert(selfTy.hasReferenceSemantics() && "can't emit a value type ctor here");
-  VarLocs[selfDecl] = VarLoc(selfArg, SILAccessEnforcement::Unknown);
+  VarLocs[selfDecl] = VarLoc::get(selfArg);
 
   auto cleanupLoc = CleanupLocation(loc);
   prepareEpilog(cd, std::nullopt, std::nullopt, cleanupLoc);
@@ -1728,11 +1727,11 @@ void SILGenFunction::emitInitAccessor(AccessorDecl *accessor) {
     loc.markAutoGenerated();
 
     SILValue argValue = F.begin()->createFunctionArgument(type, arg);
-    if (markUninitialized) {
-      argValue = B.createMarkUninitializedOut(loc, argValue);
-    }
-    
-    VarLocs[arg] = VarLoc(argValue, SILAccessEnforcement::Static);
+    VarLocs[arg] =
+        markUninitialized
+            ? VarLoc::get(B.createMarkUninitializedOut(loc, argValue))
+            : VarLoc::get(argValue);
+
     InitAccessorArgumentMappings[property] = arg;
   };
 

lib/SILGen/SILGenDecl.cpp

@@ -472,7 +472,7 @@ class DestroyLocalVariable : public Cleanup {
     Var->print(llvm::errs());
     llvm::errs() << "\n";
     if (isActive()) {
-      auto &loc = SGF.VarLocs[Var];
+      auto loc = SGF.VarLocs[Var];
       assert((loc.box || loc.value) && "One of box or value should be set");
       if (loc.box) {
         llvm::errs() << "Box: " << loc.box << "\n";
@@ -664,8 +664,7 @@ class LocalVariableInitialization : public SingleBufferInitialization {
     /// decl to.
     assert(SGF.VarLocs.count(decl) == 0 && "Already emitted the local?");
 
-    SGF.VarLocs[decl] = SILGenFunction::VarLoc(Addr,
-      SILAccessEnforcement::Dynamic, Box);
+    SGF.VarLocs[decl] = SILGenFunction::VarLoc::get(Addr, Box);
 
     SingleBufferInitialization::finishInitialization(SGF);
     assert(!DidFinish &&
@@ -678,54 +677,6 @@ class LocalVariableInitialization : public SingleBufferInitialization {
 } // end anonymous namespace
 
 namespace {
-
-static void deallocateAddressable(SILGenFunction &SGF,
-                                  SILLocation l,
-                                  SILGenFunction::VarLoc &loc) {
-  SGF.B.createEndBorrow(l, loc.addressableBuffer.state->storeBorrow);
-  SGF.B.createDeallocStack(l, loc.addressableBuffer.state->allocStack);
-  if (loc.addressableBuffer.state->reabstraction) {
-    SGF.B.createDestroyValue(l, loc.addressableBuffer.state->reabstraction);
-  }
-}
-
-/// Cleanup to deallocate the addressable buffer for a parameter or let
-/// binding.
-class DeallocateLocalVariableAddressableBuffer : public Cleanup {
-  ValueDecl *vd;
-public:
-  DeallocateLocalVariableAddressableBuffer(ValueDecl *vd) : vd(vd) {}
-
-  void emit(SILGenFunction &SGF, CleanupLocation l,
-            ForUnwind_t forUnwind) override {
-    auto found = SGF.VarLocs.find(vd);
-    if (found == SGF.VarLocs.end()) {
-      return;
-    }
-    auto &loc = found->second;
-    
-    if (loc.addressableBuffer.state) {
-      // The addressable buffer was forced, so clean it up now.
-      deallocateAddressable(SGF, l, loc);
-    } else {
-      // Remember this insert location in case we need to force the addressable
-      // buffer later.
-      SILInstruction *marker = SGF.B.createTuple(l, {});
-      loc.addressableBuffer.cleanupPoints.emplace_back(marker);
-    }
-  }
-
-  void dump(SILGenFunction &SGF) const override {
-#ifndef NDEBUG
-    llvm::errs() << "DeallocateLocalVariableAddressableBuffer\n"
-                 << "State:" << getState() << "\n"
-                 << "Decl: ";
-    vd->print(llvm::errs());
-    llvm::errs() << "\n";
-#endif
-  }
-};
-
 /// Initialize a writeback buffer that receives the value of a 'let'
 /// declaration.
 class LetValueInitialization : public Initialization {
@@ -804,8 +755,7 @@ class LetValueInitialization : public Initialization {
       if (isUninitialized)
         address = SGF.B.createMarkUninitializedVar(vd, address);
       DestroyCleanup = SGF.enterDormantTemporaryCleanup(address, *lowering);
-      SGF.VarLocs[vd] = SILGenFunction::VarLoc(address,
-                                               SILAccessEnforcement::Unknown);
+      SGF.VarLocs[vd] = SILGenFunction::VarLoc::get(address);
     }
     // Push a cleanup to destroy the let declaration.  This has to be
     // inactive until the variable is initialized: if control flow exits the
@@ -816,10 +766,6 @@ class LetValueInitialization : public Initialization {
     SGF.Cleanups.pushCleanupInState<DestroyLocalVariable>(
       CleanupState::Dormant, vd);
     DestroyCleanup = SGF.Cleanups.getTopCleanup();
-
-    // If the binding has an addressable buffer forced, it should be cleaned
-    // up here.
-    SGF.enterLocalVariableAddressableBufferScope(vd);
   }
 
   ~LetValueInitialization() override {
@@ -937,8 +883,7 @@ class LetValueInitialization : public Initialization {
     if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule()))
       value = getValueForLexicalLifetimeBinding(SGF, loc, value, wasPlusOne);
 
-    SGF.VarLocs[vd] = SILGenFunction::VarLoc(value,
-                                             SILAccessEnforcement::Unknown);
+    SGF.VarLocs[vd] = SILGenFunction::VarLoc::get(value);
 
     // Emit a debug_value[_addr] instruction to record the start of this value's
     // lifetime, if permitted to do so.
@@ -1518,7 +1463,7 @@ SILGenFunction::emitInitializationForVarDecl(VarDecl *vd, bool forceImmutable,
     assert(SILDebugClient && "Debugger client doesn't support SIL");
     SILValue SV = SILDebugClient->emitLValueForVariable(vd, B);
 
-    VarLocs[vd] = VarLoc(SV, SILAccessEnforcement::Dynamic);
+    VarLocs[vd] = SILGenFunction::VarLoc::get(SV);
     return InitializationPtr(new KnownAddressInitialization(SV));
   }
 
@@ -1549,7 +1494,7 @@ SILGenFunction::emitInitializationForVarDecl(VarDecl *vd, bool forceImmutable,
     if (isUninitialized)
       addr = B.createMarkUninitializedVar(loc, addr);
 
-    VarLocs[vd] = VarLoc(addr, SILAccessEnforcement::Dynamic);
+    VarLocs[vd] = SILGenFunction::VarLoc::get(addr);
     Result = InitializationPtr(new KnownAddressInitialization(addr));
   } else {
     std::optional<MarkUninitializedInst::Kind> uninitKind;
@@ -2364,7 +2309,7 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
     }
   };
 
-  auto &loc = VarLocs[vd];
+  auto loc = VarLocs[vd];
 
   // For a heap variable, the box is responsible for the value. We just need
   // to give up our retain count on it.
@@ -2461,101 +2406,6 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
   llvm_unreachable("unhandled case");
 }
 
-void
-SILGenFunction::enterLocalVariableAddressableBufferScope(VarDecl *decl) {
-  Cleanups.pushCleanup<DeallocateLocalVariableAddressableBuffer>(decl);
-}
-
-SILValue
-SILGenFunction::getLocalVariableAddressableBuffer(VarDecl *decl,
-                                                  SILLocation curLoc,
-                                                  ValueOwnership ownership) {
-  auto foundVarLoc = VarLocs.find(decl);
-  if (foundVarLoc == VarLocs.end()) {
-    return SILValue();
-  }
-  
-  auto &varLoc = foundVarLoc->second;
-  SILType fullyAbstractedTy = getLoweredType(AbstractionPattern::getOpaque(),
-                                     decl->getTypeInContext()->getRValueType());
-  
-  // Check whether the bound value is inherently suitable for addressability.
-  // It must already be in memory and fully abstracted.
-  if (varLoc.value->getType().isAddress()
-      && fullyAbstractedTy.getASTType()==varLoc.value->getType().getASTType()) {
-    SILValue address = varLoc.value;
-    // Begin an access if the address is mutable.
-    if (varLoc.access != SILAccessEnforcement::Unknown) {
-      address = B.emitBeginAccess(curLoc, address,
-        ownership == ValueOwnership::InOut ? SILAccessKind::Modify
-                                           : SILAccessKind::Read,
-        varLoc.access);
-    }
-    return address;
-  }
-  
-  // We can't retroactively introduce a reabstracted representation for a
-  // mutable binding (since we would now have two mutable memory locations
-  // representing the same value).
-  if (varLoc.access != SILAccessEnforcement::Unknown) {
-    return SILValue();
-  }
-  
-  assert(ownership == ValueOwnership::Shared);
-  
-  // Check whether the in-memory representation has already been forced.
-  if (auto &state = varLoc.addressableBuffer.state) {
-    return state->storeBorrow;
-  }
-  
-  // Otherwise, force the addressable representation.
-  SILValue reabstraction, allocStack, storeBorrow;
-  {
-    SavedInsertionPointRAII save(B);
-    B.setInsertionPoint(varLoc.value->getNextInstruction());
-    auto declarationLoc = varLoc.value->getDefiningInsertionPoint()->getLoc();
-    
-    // Reabstract if necessary.
-    auto value = varLoc.value;
-    reabstraction = SILValue();
-    if (value->getType().getASTType() != fullyAbstractedTy.getASTType()){
-      auto reabstracted = emitSubstToOrigValue(curLoc,
-        ManagedValue::forBorrowedRValue(value),
-        AbstractionPattern::getOpaque(),
-        decl->getTypeInContext()->getCanonicalType(),
-        SGFContext());
-      reabstraction = reabstracted.forward(*this);
-      value = reabstraction;
-    }
-    // TODO: reabstract
-    allocStack = B.createAllocStack(declarationLoc, value->getType(),
-                                    std::nullopt,
-                                    DoesNotHaveDynamicLifetime,
-                                    IsNotLexical,
-                                    IsNotFromVarDecl,
-                                    DoesNotUseMoveableValueDebugInfo,
-                                    /*skipVarDeclAssert*/ true);
-    storeBorrow = B.createStoreBorrow(declarationLoc, value, allocStack);
-  }
-  
-  // Record the addressable representation.
-  varLoc.addressableBuffer.state
-    = std::make_unique<VarLoc::AddressableBuffer::State>(reabstraction,
-                                                         allocStack,
-                                                         storeBorrow);
-
-  // Emit cleanups on any paths where we previously would have cleaned up
-  // the addressable representation if it had been forced earlier.
-  for (SILInstruction *cleanupPoint : varLoc.addressableBuffer.cleanupPoints) {
-    SavedInsertionPointRAII insertCleanup(B, cleanupPoint);
-    deallocateAddressable(*this, cleanupPoint->getLoc(), varLoc);
-    cleanupPoint->eraseFromParent();
-  }
-  varLoc.addressableBuffer.cleanupPoints.clear();
-  
-  return storeBorrow;
-}
-
 void BlackHoleInitialization::performPackExpansionInitialization(
                                         SILGenFunction &SGF,
                                         SILLocation loc,
@@ -2587,9 +2437,3 @@ void BlackHoleInitialization::copyOrInitValueInto(SILGenFunction &SGF, SILLocati
   value = SGF.B.createMoveValue(loc, value);
   SGF.B.createIgnoredUse(loc, value.getValue());
 }
-
-SILGenFunction::VarLoc::AddressableBuffer::~AddressableBuffer() {
-  for (auto cleanupPoint : cleanupPoints) {
-    cleanupPoint->eraseFromParent();
-  }
-}

lib/SILGen/SILGenFunction.cpp

@@ -770,7 +770,7 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       }
     };
 
-    auto &Entry = found->second;
+    auto Entry = found->second;
     auto val = Entry.value;
 
     switch (SGM.Types.getDeclCaptureKind(capture, expansion)) {