@@ -472,7 +472,7 @@ class DestroyLocalVariable : public Cleanup {
472472 Var->print (llvm::errs ());
473473 llvm::errs () << " \n "
474474 if (isActive ()) {
475- auto & loc = SGF.VarLocs [Var];
475+ auto loc = SGF.VarLocs [Var];
476476 assert ((loc.box || loc.value ) && " One of box or value should be set"
477477 if (loc.box ) {
478478 llvm::errs () << " Box: " box << " \n "
@@ -664,8 +664,7 @@ class LocalVariableInitialization : public SingleBufferInitialization {
664664 // / decl to.
665665 assert (SGF.VarLocs .count (decl) == 0 && " Already emitted the local?"
666666
667- SGF.VarLocs [decl] = SILGenFunction::VarLoc (Addr,
668- SILAccessEnforcement::Dynamic, Box);
667+ SGF.VarLocs [decl] = SILGenFunction::VarLoc::get (Addr, Box);
669668
670669 SingleBufferInitialization::finishInitialization (SGF);
671670 assert (!DidFinish &&
@@ -678,54 +677,6 @@ class LocalVariableInitialization : public SingleBufferInitialization {
678677} // end anonymous namespace
679678
680679namespace {
681-
682- static void deallocateAddressable (SILGenFunction &SGF,
683- SILLocation l,
684- SILGenFunction::VarLoc &loc) {
685- SGF.B .createEndBorrow (l, loc.addressableBuffer .state ->storeBorrow );
686- SGF.B .createDeallocStack (l, loc.addressableBuffer .state ->allocStack );
687- if (loc.addressableBuffer .state ->reabstraction ) {
688- SGF.B .createDestroyValue (l, loc.addressableBuffer .state ->reabstraction );
689- }
690- }
691-
692- // / Cleanup to deallocate the addressable buffer for a parameter or let
693- // / binding.
694- class DeallocateLocalVariableAddressableBuffer : public Cleanup {
695- ValueDecl *vd;
696- public:
697- DeallocateLocalVariableAddressableBuffer (ValueDecl *vd) : vd(vd) {}
698-
699- void emit (SILGenFunction &SGF, CleanupLocation l,
700- ForUnwind_t forUnwind) override {
701- auto found = SGF.VarLocs .find (vd);
702- if (found == SGF.VarLocs .end ()) {
703- return ;
704- }
705- auto &loc = found->second ;
706-
707- if (loc.addressableBuffer .state ) {
708- // The addressable buffer was forced, so clean it up now.
709- deallocateAddressable (SGF, l, loc);
710- } else {
711- // Remember this insert location in case we need to force the addressable
712- // buffer later.
713- SILInstruction *marker = SGF.B .createTuple (l, {});
714- loc.addressableBuffer .cleanupPoints .emplace_back (marker);
715- }
716- }
717-
718- void dump (SILGenFunction &SGF) const override {
719- #ifndef NDEBUG
720- llvm::errs () << " DeallocateLocalVariableAddressableBuffer\n "
721- << " State:" getState () << " \n "
722- << " Decl: "
723- vd->print (llvm::errs ());
724- llvm::errs () << " \n "
725- #endif
726- }
727- };
728-
729680// / Initialize a writeback buffer that receives the value of a 'let'
730681// / declaration.
731682class LetValueInitialization : public Initialization {
@@ -804,8 +755,7 @@ class LetValueInitialization : public Initialization {
804755 if (isUninitialized)
805756 address = SGF.B .createMarkUninitializedVar (vd, address);
806757 DestroyCleanup = SGF.enterDormantTemporaryCleanup (address, *lowering);
807- SGF.VarLocs [vd] = SILGenFunction::VarLoc (address,
808- SILAccessEnforcement::Unknown);
758+ SGF.VarLocs [vd] = SILGenFunction::VarLoc::get (address);
809759 }
810760 // Push a cleanup to destroy the let declaration. This has to be
811761 // inactive until the variable is initialized: if control flow exits the
@@ -816,10 +766,6 @@ class LetValueInitialization : public Initialization {
816766 SGF.Cleanups .pushCleanupInState <DestroyLocalVariable>(
817767 CleanupState::Dormant, vd);
818768 DestroyCleanup = SGF.Cleanups .getTopCleanup ();
819-
820- // If the binding has an addressable buffer forced, it should be cleaned
821- // up here.
822- SGF.enterLocalVariableAddressableBufferScope (vd);
823769 }
824770
825771 ~LetValueInitialization () override {
@@ -937,8 +883,7 @@ class LetValueInitialization : public Initialization {
937883 if (SGF.getASTContext ().SILOpts .supportsLexicalLifetimes (SGF.getModule ()))
938884 value = getValueForLexicalLifetimeBinding (SGF, loc, value, wasPlusOne);
939885
940- SGF.VarLocs [vd] = SILGenFunction::VarLoc (value,
941- SILAccessEnforcement::Unknown);
886+ SGF.VarLocs [vd] = SILGenFunction::VarLoc::get (value);
942887
943888 // Emit a debug_value[_addr] instruction to record the start of this value's
944889 // lifetime, if permitted to do so.
@@ -1518,7 +1463,7 @@ SILGenFunction::emitInitializationForVarDecl(VarDecl *vd, bool forceImmutable,
15181463 assert (SILDebugClient && " Debugger client doesn't support SIL"
15191464 SILValue SV = SILDebugClient->emitLValueForVariable (vd, B);
15201465
1521- VarLocs[vd] = VarLoc (SV, SILAccessEnforcement::Dynamic );
1466+ VarLocs[vd] = SILGenFunction:: VarLoc::get (SV );
15221467 return InitializationPtr (new KnownAddressInitialization (SV));
15231468 }
15241469
@@ -1549,7 +1494,7 @@ SILGenFunction::emitInitializationForVarDecl(VarDecl *vd, bool forceImmutable,
15491494 if (isUninitialized)
15501495 addr = B.createMarkUninitializedVar (loc, addr);
15511496
1552- VarLocs[vd] = VarLoc (addr, SILAccessEnforcement::Dynamic );
1497+ VarLocs[vd] = SILGenFunction:: VarLoc::get (addr );
15531498 Result = InitializationPtr (new KnownAddressInitialization (addr));
15541499 } else {
15551500 std::optional<MarkUninitializedInst::Kind> uninitKind;
@@ -2364,7 +2309,7 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
23642309 }
23652310 };
23662311
2367- auto & loc = VarLocs[vd];
2312+ auto loc = VarLocs[vd];
23682313
23692314 // For a heap variable, the box is responsible for the value. We just need
23702315 // to give up our retain count on it.
@@ -2461,101 +2406,6 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
24612406 llvm_unreachable (" unhandled case"
24622407}
24632408
2464- void
2465- SILGenFunction::enterLocalVariableAddressableBufferScope (VarDecl *decl) {
2466- Cleanups.pushCleanup <DeallocateLocalVariableAddressableBuffer>(decl);
2467- }
2468-
2469- SILValue
2470- SILGenFunction::getLocalVariableAddressableBuffer (VarDecl *decl,
2471- SILLocation curLoc,
2472- ValueOwnership ownership) {
2473- auto foundVarLoc = VarLocs.find (decl);
2474- if (foundVarLoc == VarLocs.end ()) {
2475- return SILValue ();
2476- }
2477-
2478- auto &varLoc = foundVarLoc->second ;
2479- SILType fullyAbstractedTy = getLoweredType (AbstractionPattern::getOpaque (),
2480- decl->getTypeInContext ()->getRValueType ());
2481-
2482- // Check whether the bound value is inherently suitable for addressability.
2483- // It must already be in memory and fully abstracted.
2484- if (varLoc.value ->getType ().isAddress ()
2485- && fullyAbstractedTy.getASTType ()==varLoc.value ->getType ().getASTType ()) {
2486- SILValue address = varLoc.value ;
2487- // Begin an access if the address is mutable.
2488- if (varLoc.access != SILAccessEnforcement::Unknown) {
2489- address = B.emitBeginAccess (curLoc, address,
2490- ownership == ValueOwnership::InOut ? SILAccessKind::Modify
2491- : SILAccessKind::Read,
2492- varLoc.access );
2493- }
2494- return address;
2495- }
2496-
2497- // We can't retroactively introduce a reabstracted representation for a
2498- // mutable binding (since we would now have two mutable memory locations
2499- // representing the same value).
2500- if (varLoc.access != SILAccessEnforcement::Unknown) {
2501- return SILValue ();
2502- }
2503-
2504- assert (ownership == ValueOwnership::Shared);
2505-
2506- // Check whether the in-memory representation has already been forced.
2507- if (auto &state = varLoc.addressableBuffer .state ) {
2508- return state->storeBorrow ;
2509- }
2510-
2511- // Otherwise, force the addressable representation.
2512- SILValue reabstraction, allocStack, storeBorrow;
2513- {
2514- SavedInsertionPointRAII save (B);
2515- B.setInsertionPoint (varLoc.value ->getNextInstruction ());
2516- auto declarationLoc = varLoc.value ->getDefiningInsertionPoint ()->getLoc ();
2517-
2518- // Reabstract if necessary.
2519- auto value = varLoc.value ;
2520- reabstraction = SILValue ();
2521- if (value->getType ().getASTType () != fullyAbstractedTy.getASTType ()){
2522- auto reabstracted = emitSubstToOrigValue (curLoc,
2523- ManagedValue::forBorrowedRValue (value),
2524- AbstractionPattern::getOpaque (),
2525- decl->getTypeInContext ()->getCanonicalType (),
2526- SGFContext ());
2527- reabstraction = reabstracted.forward (*this );
2528- value = reabstraction;
2529- }
2530- // TODO: reabstract
2531- allocStack = B.createAllocStack (declarationLoc, value->getType (),
2532- std::nullopt,
2533- DoesNotHaveDynamicLifetime,
2534- IsNotLexical,
2535- IsNotFromVarDecl,
2536- DoesNotUseMoveableValueDebugInfo,
2537- /* skipVarDeclAssert*/ true );
2538- storeBorrow = B.createStoreBorrow (declarationLoc, value, allocStack);
2539- }
2540-
2541- // Record the addressable representation.
2542- varLoc.addressableBuffer .state
2543- = std::make_unique<VarLoc::AddressableBuffer::State>(reabstraction,
2544- allocStack,
2545- storeBorrow);
2546-
2547- // Emit cleanups on any paths where we previously would have cleaned up
2548- // the addressable representation if it had been forced earlier.
2549- for (SILInstruction *cleanupPoint : varLoc.addressableBuffer .cleanupPoints ) {
2550- SavedInsertionPointRAII insertCleanup (B, cleanupPoint);
2551- deallocateAddressable (*this , cleanupPoint->getLoc (), varLoc);
2552- cleanupPoint->eraseFromParent ();
2553- }
2554- varLoc.addressableBuffer .cleanupPoints .clear ();
2555-
2556- return storeBorrow;
2557- }
2558-
25592409void BlackHoleInitialization::performPackExpansionInitialization (
25602410 SILGenFunction &SGF,
25612411 SILLocation loc,
@@ -2587,9 +2437,3 @@ void BlackHoleInitialization::copyOrInitValueInto(SILGenFunction &SGF, SILLocati
25872437 value = SGF.B .createMoveValue (loc, value);
25882438 SGF.B .createIgnoredUse (loc, value.getValue ());
25892439}
2590-
2591- SILGenFunction::VarLoc::AddressableBuffer::~AddressableBuffer () {
2592- for (auto cleanupPoint : cleanupPoints) {
2593- cleanupPoint->eraseFromParent ();
2594- }
2595- }
0 commit comments