[NFC] SIL: Typed alloc_stack's isLexical.

nate-chandler · nate-chandler · commit c6eb3112b570 · 2024-03-08T21:24:39.000-08:00
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -1463,7 +1463,8 @@ BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,
                                     bool hasDynamicLifetime, bool isLexical, bool wasMoved) const {
   return {unbridged().createAllocStack(
       regularLoc(), type.unbridged(), std::nullopt,
-      swift::HasDynamicLifetime_t(hasDynamicLifetime), isLexical,
+      swift::HasDynamicLifetime_t(hasDynamicLifetime),
+      swift::IsLexical_t(isLexical),
       swift::UsesMoveableValueDebugInfo_t(wasMoved))};
 }
 
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -406,7 +406,7 @@ class SILBuilder {
       SILLocation Loc, SILType elementType,
       std::optional<SILDebugVariable> Var = std::nullopt,
       HasDynamicLifetime_t dynamic = DoesNotHaveDynamicLifetime,
-      bool isLexical = false,
+      IsLexical_t isLexical = IsNotLexical,
       UsesMoveableValueDebugInfo_t wasMoved = DoesNotUseMoveableValueDebugInfo,
       bool skipVarDeclAssert = false) {
     llvm::SmallString<4> Name;
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -1973,6 +1973,11 @@ enum HasDynamicLifetime_t : bool {
   HasDynamicLifetime = true,
 };
 
+enum IsLexical_t : bool {
+  IsNotLexical = false,
+  IsLexical = true,
+};
+
 /// AllocStackInst - This represents the allocation of an unboxed (i.e., no
 /// reference count) stack memory.  The memory is provided uninitialized.
 class AllocStackInst final
@@ -1992,14 +1997,14 @@ class AllocStackInst final
   AllocStackInst(SILDebugLocation Loc, SILType elementType,
                  ArrayRef<SILValue> TypeDependentOperands, SILFunction &F,
                  std::optional<SILDebugVariable> Var,
-                 HasDynamicLifetime_t hasDynamicLifetime, bool isLexical,
+                 HasDynamicLifetime_t hasDynamicLifetime, IsLexical_t isLexical,
                  UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo);
 
   static AllocStackInst *create(SILDebugLocation Loc, SILType elementType,
                                 SILFunction &F,
                                 std::optional<SILDebugVariable> Var,
                                 HasDynamicLifetime_t hasDynamicLifetime,
-                                bool isLexical,
+                                IsLexical_t isLexical,
                                 UsesMoveableValueDebugInfo_t wasMoved);
 
   SIL_DEBUG_VAR_SUPPLEMENT_TRAILING_OBJS_IMPL()
@@ -2048,15 +2053,21 @@ class AllocStackInst final
   }
 
   /// Whether the alloc_stack instruction corresponds to a source-level VarDecl.
-  bool isLexical() const { return sharedUInt8().AllocStackInst.lexical; }
+  IsLexical_t isLexical() const {
+    return IsLexical_t(sharedUInt8().AllocStackInst.lexical);
+  }
 
   /// If this is a lexical alloc_stack, eliminate the lexical bit. If this
   /// alloc_stack doesn't have a lexical bit, do not do anything.
-  void removeIsLexical() { sharedUInt8().AllocStackInst.lexical = false; }
+  void removeIsLexical() {
+    sharedUInt8().AllocStackInst.lexical = (bool)IsNotLexical;
+  }
 
   /// If this is not a lexical alloc_stack, set the lexical bit. If this
   /// alloc_stack is already lexical, this does nothing.
-  void setIsLexical() { sharedUInt8().AllocStackInst.lexical = true; }
+  void setIsLexical() {
+    sharedUInt8().AllocStackInst.lexical = (bool)IsLexical;
+  }
 
   /// Return the debug variable information attached to this instruction.
   std::optional<SILDebugVariable> getVarInfo() const {
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
@@ -170,12 +170,6 @@ enum IsInfiniteType_t : bool {
   IsInfiniteType = true,
 };
 
-/// Does this type contain at least one non-trivial, non-eager-move type?
-enum IsLexical_t : bool {
-  IsNotLexical = false,
-  IsLexical = true,
-};
-
 /// Does this type contain any pack-like thing.
 enum HasPack_t : bool {
   HasNoPack = false,
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -226,7 +226,7 @@ AllocStackInst::AllocStackInst(
     SILDebugLocation Loc, SILType elementType,
     ArrayRef<SILValue> TypeDependentOperands, SILFunction &F,
     std::optional<SILDebugVariable> Var,
-    HasDynamicLifetime_t hasDynamicLifetime, bool isLexical,
+    HasDynamicLifetime_t hasDynamicLifetime, IsLexical_t isLexical,
     UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo)
     : InstructionBase(Loc, elementType.getAddressType()),
       SILDebugVariableSupplement(Var ? Var->DIExpr.getNumElements() : 0,
@@ -237,7 +237,7 @@ AllocStackInst::AllocStackInst(
       // initialization can only be done after `numOperands` is set (see below).
       VarInfo(0) {
   sharedUInt8().AllocStackInst.dynamicLifetime = (bool)hasDynamicLifetime;
-  sharedUInt8().AllocStackInst.lexical = isLexical;
+  sharedUInt8().AllocStackInst.lexical = (bool)isLexical;
   sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo =
       (bool)usesMoveableValueDebugInfo || elementType.isMoveOnly();
   sharedUInt32().AllocStackInst.numOperands = TypeDependentOperands.size();
@@ -266,7 +266,7 @@ AllocStackInst *AllocStackInst::create(SILDebugLocation Loc,
                                        SILType elementType, SILFunction &F,
                                        std::optional<SILDebugVariable> Var,
                                        HasDynamicLifetime_t hasDynamicLifetime,
-                                       bool isLexical,
+                                       IsLexical_t isLexical,
                                        UsesMoveableValueDebugInfo_t wasMoved) {
   SmallVector<SILValue, 8> TypeDependentOperands;
   collectTypeDependentOperands(TypeDependentOperands, F,
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -4741,7 +4741,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   }
   case SILInstructionKind::AllocStackInst: {
     auto hasDynamicLifetime = DoesNotHaveDynamicLifetime;
-    bool isLexical = false;
+    auto isLexical = IsNotLexical;
     UsesMoveableValueDebugInfo_t usesMoveableValueDebugInfo =
         DoesNotUseMoveableValueDebugInfo;
 
@@ -4751,7 +4751,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       if (attributeName == "dynamic_lifetime")
         hasDynamicLifetime = HasDynamicLifetime;
       else if (attributeName == "lexical")
-        isLexical = true;
+        isLexical = IsLexical;
       else if (attributeName == "moveable_value_debuginfo")
         usesMoveableValueDebugInfo = UsesMoveableValueDebugInfo;
       else {
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
@@ -708,7 +708,8 @@ class LetValueInitialization : public Initialization {
       bool lexicalLifetimesEnabled =
           SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule());
       auto lifetime = SGF.F.getLifetime(vd, lowering->getLoweredType());
-      auto isLexical = lexicalLifetimesEnabled && lifetime.isLexical();
+      auto isLexical =
+          IsLexical_t(lexicalLifetimesEnabled && lifetime.isLexical());
       address =
           SGF.emitTemporaryAllocation(vd, lowering->getLoweredType(),
                                       DoesNotHaveDynamicLifetime, isLexical);
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -1093,7 +1093,7 @@ RValue RValueEmitter::visitLoadExpr(LoadExpr *E, SGFContext C) {
 
 SILValue SILGenFunction::emitTemporaryAllocation(SILLocation loc, SILType ty,
                                                  HasDynamicLifetime_t dynamic,
-                                                 bool isLexical,
+                                                 IsLexical_t isLexical,
                                                  bool generateDebugInfo) {
   ty = ty.getObjectType();
   std::optional<SILDebugVariable> DbgVar;
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -699,9 +699,9 @@ void SILGenFunction::emitCaptures(SILLocation loc,
 
         assert(!isPack);
 
-        auto addr = emitTemporaryAllocation(vd, entryValue->getType(),
-                                            DoesNotHaveDynamicLifetime, false,
-                                            /*generateDebugInfo*/ false);
+        auto addr = emitTemporaryAllocation(
+            vd, entryValue->getType(), DoesNotHaveDynamicLifetime, IsNotLexical,
+            /*generateDebugInfo*/ false);
         auto val = B.emitCopyValueOperation(loc, entryValue);
         auto &lowering = getTypeLowering(entryValue->getType());
         lowering.emitStore(B, loc, val, addr, StoreOwnershipQualifier::Init);
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -1335,7 +1335,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   SILValue emitTemporaryAllocation(
       SILLocation loc, SILType ty,
       HasDynamicLifetime_t hasDynamicLifetime = DoesNotHaveDynamicLifetime,
-      bool isLexical = false, bool generateDebugInfo = true);
+      IsLexical_t isLexical = IsNotLexical, bool generateDebugInfo = true);
 
   /// Emits a temporary allocation for a pack that will be deallocated
   /// automatically at the end of the current scope.  Returns the address
diff --git a/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp b/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp
@@ -624,12 +624,12 @@ static bool rewriteAllocBoxAsAllocStack(AllocBoxInst *ABI) {
          && "rewriting multi-field box not implemented");
   auto ty = getSILBoxFieldType(TypeExpansionContext(*ABI->getFunction()),
                                ABI->getBoxType(), ABI->getModule().Types, 0);
-  auto isLexical = [&]() -> bool {
+  auto isLexical = [&]() -> IsLexical_t {
     auto &mod = ABI->getFunction()->getModule();
     bool lexicalLifetimesEnabled =
         mod.getASTContext().SILOpts.supportsLexicalLifetimes(mod);
     if (!lexicalLifetimesEnabled)
-      return false;
+      return IsNotLexical;
     // Look for lexical borrows of the alloc_box.
     GraphNodeWorklist<Operand *, 4> worklist;
     worklist.initializeRange(ABI->getUses());
@@ -642,12 +642,12 @@ static bool rewriteAllocBoxAsAllocStack(AllocBoxInst *ABI) {
           worklist.insert(use);
       } else if (auto *bbi = dyn_cast<BeginBorrowInst>(use->getUser())) {
         if (bbi->isLexical())
-          return true;
+          return IsLexical;
         for (auto *use : bbi->getUses())
           worklist.insert(use);
       }
     }
-    return false;
+    return IsNotLexical;
   };
   auto *ASI = Builder.createAllocStack(ABI->getLoc(), ty, ABI->getVarInfo(),
                                        ABI->hasDynamicLifetime(), isLexical(),
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1393,7 +1393,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   case SILInstructionKind::AllocStackInst: {
     assert(RecordKind == SIL_ONE_TYPE && "Layout should be OneType.");
     auto hasDynamicLifetime = HasDynamicLifetime_t(Attr & 0x1);
-    bool isLexical = (Attr >> 1) & 0x1;
+    auto isLexical = IsLexical_t((Attr >> 1) & 0x1);
     auto wasMoved = UsesMoveableValueDebugInfo_t((Attr >> 2) & 0x1);
     ResultInst = Builder.createAllocStack(
         Loc, getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn),

Original file line number	Diff line number	Diff line change
`@@ -1463,7 +1463,8 @@ BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,`
`1463`	`1463`	`bool hasDynamicLifetime, bool isLexical, bool wasMoved) const {`
`1464`	`1464`	`return {unbridged().createAllocStack(`
`1465`	`1465`	`regularLoc(), type.unbridged(), std::nullopt,`
`1466`		`- swift::HasDynamicLifetime_t(hasDynamicLifetime), isLexical,`
	`1466`	`+ swift::HasDynamicLifetime_t(hasDynamicLifetime),`
	`1467`	`+ swift::IsLexical_t(isLexical),`
`1467`	`1468`	`swift::UsesMoveableValueDebugInfo_t(wasMoved))};`
`1468`	`1469`	`}`
`1469`	`1470`