[SIL] Added var_decl flag to borrows/moves.

nate-chandler · nate-chandler · commit b4f783e660c1 · 2023-11-28T07:26:08.000-08:00
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -4514,12 +4514,16 @@ live. This makes sense semantically since ``%1`` is modeling a new value with a
 dependent lifetime on ``%0``.
 
 The optional ``lexical`` attribute specifies that the operand corresponds to a
-local variable in the Swift source, so special care must be taken when moving
-the end_borrow.
+local variable with a lexical lifetime in the Swift source, so special care
+must be taken when moving the end_borrow.  Compare to the ``var_decl``
+attribute.
 
 The optional ``pointer_escape`` attribute specifies that a pointer to the
 operand escapes within the borrow scope introduced by this begin_borrow.
 
+The optional ``var_decl`` attribute specifies that the operand corresponds to a
+local variable in the Swift source.
+
 This instruction is only valid in functions in Ownership SSA form.
 
 end_borrow
@@ -6376,11 +6380,15 @@ values'. A move_value instruction is an instruction that introduces (or injects)
 a type `T` into the move only value space.
 
 The ``lexical`` attribute specifies that the value corresponds to a local
-variable in the Swift source.
+variable with a lexical lifetime in the Swift source.  Compare to the
+``var_decl`` attribute.
 
 The optional ``pointer_escape`` attribute specifies that a pointer to the
 operand escapes within the scope introduced by this move_value.
 
+The optional ``var_decl`` attribute specifies that the operand corresponds to a
+local variable in the Swift source.
+
 
 drop_deinit
 ```````````
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -804,11 +804,13 @@ class SILBuilder {
 
   BeginBorrowInst *createBeginBorrow(SILLocation Loc, SILValue LV,
                                      bool isLexical = false,
-                                     bool hasPointerEscape = false) {
+                                     bool hasPointerEscape = false,
+                                     bool fromVarDecl = false) {
     assert(getFunction().hasOwnership());
     assert(!LV->getType().isAddress());
-    return insert(new (getModule()) BeginBorrowInst(getSILDebugLocation(Loc),
-                                                    LV, isLexical, hasPointerEscape));
+    return insert(new (getModule())
+                      BeginBorrowInst(getSILDebugLocation(Loc), LV, isLexical,
+                                      hasPointerEscape, fromVarDecl));
   }
 
   /// Convenience function for creating a load_borrow on non-trivial values and
@@ -1402,13 +1404,15 @@ class SILBuilder {
 
   MoveValueInst *createMoveValue(SILLocation loc, SILValue operand,
                                  bool isLexical = false,
-                                 bool hasPointerEscape = false) {
+                                 bool hasPointerEscape = false,
+                                 bool fromVarDecl = false) {
     assert(getFunction().hasOwnership());
     assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
            "emitMoveValueOperation");
-    return insert(new (getModule()) MoveValueInst(
-        getSILDebugLocation(loc), operand, isLexical, hasPointerEscape));
+    return insert(new (getModule())
+                      MoveValueInst(getSILDebugLocation(loc), operand,
+                                    isLexical, hasPointerEscape, fromVarDecl));
   }
 
   DropDeinitInst *createDropDeinit(SILLocation loc, SILValue operand) {
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -1217,10 +1217,11 @@ void SILCloner<ImplClass>::visitBeginBorrowInst(BeginBorrowInst *Inst) {
     return recordFoldedValue(Inst, getOpValue(Inst->getOperand()));
   }
 
-  recordClonedInstruction(
-      Inst, getBuilder().createBeginBorrow(
-                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
-                Inst->isLexical(), Inst->hasPointerEscape()));
+  recordClonedInstruction(Inst,
+                          getBuilder().createBeginBorrow(
+                              getOpLocation(Inst->getLoc()),
+                              getOpValue(Inst->getOperand()), Inst->isLexical(),
+                              Inst->hasPointerEscape(), Inst->isFromVarDecl()));
 }
 
 template <typename ImplClass>
@@ -1932,7 +1933,7 @@ void SILCloner<ImplClass>::visitMoveValueInst(MoveValueInst *Inst) {
   }
   auto *MVI = getBuilder().createMoveValue(
       getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
-      Inst->isLexical(), Inst->hasPointerEscape());
+      Inst->isLexical(), Inst->hasPointerEscape(), Inst->isFromVarDecl());
   MVI->setAllowsDiagnostics(Inst->getAllowDiagnostics());
   recordClonedInstruction(Inst, MVI);
 }
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -4398,11 +4398,12 @@ class BeginBorrowInst
   USE_SHARED_UINT8;
 
   BeginBorrowInst(SILDebugLocation DebugLoc, SILValue LValue, bool isLexical,
-                  bool hasPointerEscape)
+                  bool hasPointerEscape, bool fromVarDecl)
       : UnaryInstructionBase(DebugLoc, LValue,
                              LValue->getType().getObjectType()) {
     sharedUInt8().BeginBorrowInst.lexical = isLexical;
     sharedUInt8().BeginBorrowInst.pointerEscape = hasPointerEscape;
+    sharedUInt8().BeginBorrowInst.fromVarDecl = fromVarDecl;
   }
 
 public:
@@ -4428,6 +4429,10 @@ class BeginBorrowInst
     sharedUInt8().BeginBorrowInst.pointerEscape = pointerEscape;
   }
 
+  bool isFromVarDecl() const {
+    return sharedUInt8().BeginBorrowInst.fromVarDecl;
+  }
+
   /// Return a range over all EndBorrow instructions for this BeginBorrow.
   EndBorrowRange getEndBorrows() const;
 
@@ -8374,10 +8379,11 @@ class MoveValueInst
   USE_SHARED_UINT8;
 
   MoveValueInst(SILDebugLocation DebugLoc, SILValue operand, bool isLexical,
-                bool hasPointerEscape)
+                bool hasPointerEscape, bool fromVarDecl)
       : UnaryInstructionBase(DebugLoc, operand, operand->getType()) {
     sharedUInt8().MoveValueInst.lexical = isLexical;
     sharedUInt8().MoveValueInst.pointerEscape = hasPointerEscape;
+    sharedUInt8().MoveValueInst.fromVarDecl = fromVarDecl;
   }
 
 public:
@@ -8400,6 +8406,8 @@ class MoveValueInst
   void setHasPointerEscape(bool pointerEscape) {
     sharedUInt8().MoveValueInst.pointerEscape = pointerEscape;
   }
+
+  bool isFromVarDecl() const { return sharedUInt8().MoveValueInst.fromVarDecl; }
 };
 
 class DropDeinitInst
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -241,7 +241,8 @@ class alignas(8) SILNode :
 
     SHARED_FIELD(BeginBorrowInst, uint8_t
                  lexical : 1,
-                 pointerEscape : 1);
+                 pointerEscape : 1,
+                 fromVarDecl : 1);
 
     SHARED_FIELD(CopyAddrInst, uint8_t
       isTakeOfSrc : 1,
@@ -272,7 +273,8 @@ class alignas(8) SILNode :
     SHARED_FIELD(MoveValueInst, uint8_t
                  allowDiagnostics : 1,
                  lexical : 1,
-                 pointerEscape : 1);
+                 pointerEscape : 1,
+                 fromVarDecl : 1);
 
   // Do not use `_sharedUInt8_private` outside of SILNode.
   } _sharedUInt8_private;
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1701,6 +1701,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (BBI->hasPointerEscape()) {
       *this << "[pointer_escape] ";
     }
+    if (BBI->isFromVarDecl()) {
+      *this << "[var_decl] ";
+    }
     *this << getIDAndType(BBI->getOperand());
   }
 
@@ -2074,6 +2077,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "[lexical] ";
     if (I->hasPointerEscape())
       *this << "[pointer_escape] ";
+    if (I->isFromVarDecl())
+      *this << "[var_decl] ";
     *this << getIDAndType(I->getOperand());
   }
 
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -3846,6 +3846,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     bool allowsDiagnostics = false;
     bool isLexical = false;
     bool hasPointerEscape = false;
+    bool fromVarDecl = false;
 
     StringRef AttrName;
     SourceLoc AttrLoc;
@@ -3856,6 +3857,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         isLexical = true;
       else if (AttrName == "pointer_escape")
         hasPointerEscape = true;
+      else if (AttrName == "var_decl")
+        fromVarDecl = true;
       else {
         P.diagnose(InstLoc.getSourceLoc(),
                    diag::sil_invalid_attribute_for_instruction, AttrName,
@@ -3868,7 +3871,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       return true;
     if (parseSILDebugLocation(InstLoc, B))
       return true;
-    auto *MVI = B.createMoveValue(InstLoc, Val, isLexical, hasPointerEscape);
+    auto *MVI = B.createMoveValue(InstLoc, Val, isLexical, hasPointerEscape,
+                                  fromVarDecl);
     MVI->setAllowsDiagnostics(allowsDiagnostics);
     ResultVal = MVI;
     break;
@@ -4077,6 +4081,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
 
     bool isLexical = false;
     bool hasPointerEscape = false;
+    bool fromVarDecl = false;
 
     StringRef AttrName;
     SourceLoc AttrLoc;
@@ -4085,6 +4090,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         isLexical = true;
       else if (AttrName == "pointer_escape")
         hasPointerEscape = true;
+      else if (AttrName == "var_decl")
+        fromVarDecl = true;
       else {
         P.diagnose(InstLoc.getSourceLoc(),
                    diag::sil_invalid_attribute_for_instruction, AttrName,
@@ -4097,7 +4104,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         parseSILDebugLocation(InstLoc, B))
       return true;
 
-    ResultVal = B.createBeginBorrow(InstLoc, Val, isLexical, hasPointerEscape);
+    ResultVal = B.createBeginBorrow(InstLoc, Val, isLexical, hasPointerEscape,
+                                    fromVarDecl);
     break;
   }
 
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -2154,11 +2154,12 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     assert(RecordKind == SIL_ONE_OPERAND && "Layout should be OneOperand.");
     bool isLexical = Attr & 0x1;
     bool hasPointerEscape = (Attr >> 1) & 0x1;
+    bool fromVarDecl = (Attr >> 2) & 0x1;
     ResultInst = Builder.createBeginBorrow(
         Loc,
         getLocalValue(ValID, getSILType(MF->getType(TyID),
                                         (SILValueCategory)TyCategory, Fn)),
-        isLexical, hasPointerEscape);
+        isLexical, hasPointerEscape, fromVarDecl);
     break;
   }
 
@@ -2245,10 +2246,11 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     bool AllowsDiagnostics = Attr & 0x1;
     bool IsLexical = (Attr >> 1) & 0x1;
     bool IsEscaping = (Attr >> 2) & 0x1;
+    bool IsFromVarDecl = (Attr >> 3) & 0x1;
     auto *MVI = Builder.createMoveValue(
         Loc,
         getLocalValue(ValID, getSILType(Ty, (SILValueCategory)TyCategory, Fn)),
-        IsLexical, IsEscaping);
+        IsLexical, IsEscaping, IsFromVarDecl);
     MVI->setAllowsDiagnostics(AllowsDiagnostics);
     ResultInst = MVI;
     break;
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 819; // _resultDependsOnSelf
+const uint16_t SWIFTMODULE_VERSION_MINOR = 820; // begin_borrow/move_value [var_decl]
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
@@ -435,7 +435,7 @@ namespace sil_block {
   // SIL instructions with one typed valueref. (dealloc_stack, return)
   using SILOneOperandLayout =
       BCRecordLayout<SIL_ONE_OPERAND, SILInstOpCodeField,
-                     BCFixed<3>, // Optional attributes
+                     BCFixed<4>, // Optional attributes
                      TypeIDField, SILTypeCategoryField, ValueIDField>;
 
   using SILOneOperandExtraAttributeLayout = BCRecordLayout<
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1525,12 +1525,14 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     } else if (auto *ECMI = dyn_cast<EndCOWMutationInst>(&SI)) {
       Attr = ECMI->doKeepUnique();
     } else if (auto *BBI = dyn_cast<BeginBorrowInst>(&SI)) {
-      Attr =
-          unsigned(BBI->isLexical()) | unsigned(BBI->hasPointerEscape() << 1);
+      Attr = unsigned(BBI->isLexical()) |
+             (unsigned(BBI->hasPointerEscape() << 1)) |
+             (unsigned(BBI->isFromVarDecl() << 2));
     } else if (auto *MVI = dyn_cast<MoveValueInst>(&SI)) {
       Attr = unsigned(MVI->getAllowDiagnostics()) |
              (unsigned(MVI->isLexical() << 1)) |
-             (unsigned(MVI->hasPointerEscape() << 2));
+             (unsigned(MVI->hasPointerEscape() << 2)) |
+             (unsigned(MVI->isFromVarDecl() << 3));
     } else if (auto *I = dyn_cast<MarkUnresolvedNonCopyableValueInst>(&SI)) {
       Attr = unsigned(I->getCheckKind());
     } else if (auto *I = dyn_cast<MarkUnresolvedReferenceBindingInst>(&SI)) {
diff --git a/test/SIL/Parser/basic2.sil b/test/SIL/Parser/basic2.sil
@@ -52,7 +52,8 @@ bb0(%0 : @owned $Builtin.NativeObject):
 // CHECK-NEXT: [[REGISTER_4:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_3]]
 // CHECK-NEXT: [[REGISTER_5:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_4]]
 // CHECK-NEXT: [[REGISTER_6:%[^,]+]] = move_value [allows_diagnostics] [lexical] [pointer_escape] [[REGISTER_5]]
-// CHECK-NEXT: return [[REGISTER_6]]
+// CHECK-NEXT: [[REGISTER_7:%[^,]+]] = move_value [var_decl] [[REGISTER_6]]
+// CHECK-NEXT: return [[REGISTER_7]]
 // CHECK-NEXT: } // end sil function 'test_movevalue_parsing'
 sil [ossa] @test_movevalue_parsing : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 bb0(%0 : @owned $Builtin.NativeObject):
@@ -62,7 +63,8 @@ bb0(%0 : @owned $Builtin.NativeObject):
   %4 = move_value [allows_diagnostics] [lexical] %3 : $Builtin.NativeObject
   %5 = move_value [lexical] [allows_diagnostics] %4 : $Builtin.NativeObject
   %6 = move_value [pointer_escape] [lexical] [allows_diagnostics] %5 : $Builtin.NativeObject
-  return %6 : $Builtin.NativeObject
+  %7 = move_value [var_decl] %6 : $Builtin.NativeObject
+  return %7 : $Builtin.NativeObject
 }
 
 // CHECK-LABEL: sil [ossa] @test_debug_value_alloc_stack_moved : $@convention(thin) (@owned Builtin.NativeObject) -> () {
@@ -284,4 +286,4 @@ bb0(%0 : $*Builtin.NativeObject, %1 : @owned $Builtin.NativeObject):
   dealloc_stack %2 : $*((), (Builtin.NativeObject, Builtin.NativeObject))
   %9999 = tuple ()
   return %9999 : $()
-}
+}
diff --git a/test/SIL/Parser/borrow.sil b/test/SIL/Parser/borrow.sil
@@ -33,13 +33,16 @@ class C {}
 // CHECK-LABEL: sil [ossa] @foo
 // CHECK: begin_borrow {{%[^,]+}}
 // CHECK: begin_borrow [lexical] {{%[^,]+}}
+// CHECK: begin_borrow [var_decl] {{%[^,]+}}
 // CHECK-LABEL: } // end sil function 'foo'
 sil [ossa] @foo : $@convention(thin) () -> () {
   %instance = alloc_ref $C
   %guaranteed_c2 = begin_borrow %instance : $C
   end_borrow %guaranteed_c2 : $C
   %guaranteed_c = begin_borrow [lexical] %instance : $C
   end_borrow %guaranteed_c : $C
+  %guaranteed_c3 = begin_borrow [var_decl] %instance : $C
+  end_borrow %guaranteed_c3 : $C
   destroy_value %instance : $C
   %res = tuple ()
   return %res : $()
diff --git a/test/SIL/Serialization/basic.sil b/test/SIL/Serialization/basic.sil
@@ -91,7 +91,8 @@ bb0:
 // CHECK-NEXT: [[REGISTER_3:%[^,]+]] = move_value [lexical] [[REGISTER_2]]
 // CHECK-NEXT: [[REGISTER_4:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_3]]
 // CHECK-NEXT: [[REGISTER_5:%[^,]+]] = move_value [allows_diagnostics] [lexical] [[REGISTER_4]]
-// CHECK-NEXT: return [[REGISTER_5]]
+// CHECK-NEXT: [[REGISTER_6:%[^,]+]] = move_value [var_decl] [[REGISTER_5]]
+// CHECK-NEXT: return [[REGISTER_6]]
 // CHECK-NEXT: } // end sil function 'test_movevalue_parsing'
 sil [ossa] @test_movevalue_parsing : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 bb0(%0 : @owned $Builtin.NativeObject):
@@ -100,7 +101,8 @@ bb0(%0 : @owned $Builtin.NativeObject):
   %3 = move_value [lexical] %2 : $Builtin.NativeObject
   %4 = move_value [allows_diagnostics] [lexical] %3 : $Builtin.NativeObject
   %5 = move_value [lexical] [allows_diagnostics] %4 : $Builtin.NativeObject
-  return %5 : $Builtin.NativeObject
+  %6 = move_value [var_decl] %5 : $Builtin.NativeObject
+  return %6 : $Builtin.NativeObject
 }
 
 // CHECK-LABEL: sil [no_allocation] [ossa] @test_no_allocation : $@convention(thin) () -> () {
diff --git a/test/SIL/Serialization/borrow.sil b/test/SIL/Serialization/borrow.sil
@@ -11,13 +11,16 @@ import Builtin
 // CHECK-LABEL: sil [serialized] [ossa] @begin_borrow_test
 // CHECK: begin_borrow [lexical] {{%[^,]+}}
 // CHECK: begin_borrow {{%[^,]+}}
+// CHECK: begin_borrow [var_decl] {{%[^,]+}}
 // CHECK: } // end sil function 'begin_borrow_test'
 sil [serialized] [ossa] @begin_borrow_test : $@convention(thin) () -> () {
   %instance = alloc_ref $C
   %guaranteed_c = begin_borrow [lexical] %instance : $C
   end_borrow %guaranteed_c : $C
   %guaranteed_c2 = begin_borrow %instance : $C
   end_borrow %guaranteed_c2 : $C
+  %guaranteed_c3 = begin_borrow [var_decl] %instance : $C
+  end_borrow %guaranteed_c3 : $C
   destroy_value %instance : $C
   %res = tuple ()
   return %res : $()
diff --git a/test/SIL/cloning.sil b/test/SIL/cloning.sil

Original file line number	Diff line number	Diff line change
`@@ -1217,10 +1217,11 @@ void SILCloner<ImplClass>::visitBeginBorrowInst(BeginBorrowInst *Inst) {`
`1217`	`1217`	`return recordFoldedValue(Inst, getOpValue(Inst->getOperand()));`
`1218`	`1218`	`}`
`1219`	`1219`
`1220`		`- recordClonedInstruction(`
`1221`		`- Inst, getBuilder().createBeginBorrow(`
`1222`		`- getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),`
`1223`		`- Inst->isLexical(), Inst->hasPointerEscape()));`
	`1220`	`+ recordClonedInstruction(Inst,`
	`1221`	`+ getBuilder().createBeginBorrow(`
	`1222`	`+ getOpLocation(Inst->getLoc()),`
	`1223`	`+ getOpValue(Inst->getOperand()), Inst->isLexical(),`
	`1224`	`+ Inst->hasPointerEscape(), Inst->isFromVarDecl()));`
`1224`	`1225`	`}`
`1225`	`1226`
`1226`	`1227`	`template <typename ImplClass>`
`@@ -1932,7 +1933,7 @@ void SILCloner<ImplClass>::visitMoveValueInst(MoveValueInst *Inst) {`
`1932`	`1933`	`}`
`1933`	`1934`	`auto *MVI = getBuilder().createMoveValue(`
`1934`	`1935`	`getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),`
`1935`		`- Inst->isLexical(), Inst->hasPointerEscape());`
	`1936`	`+ Inst->isLexical(), Inst->hasPointerEscape(), Inst->isFromVarDecl());`
`1936`	`1937`	`MVI->setAllowsDiagnostics(Inst->getAllowDiagnostics());`
`1937`	`1938`	`recordClonedInstruction(Inst, MVI);`
`1938`	`1939`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1701,6 +1701,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {`
`1701`	`1701`	`if (BBI->hasPointerEscape()) {`
`1702`	`1702`	`*this << "[pointer_escape] ";`
`1703`	`1703`	`}`
	`1704`	`+ if (BBI->isFromVarDecl()) {`
	`1705`	`+ *this << "[var_decl] ";`
	`1706`	`+ }`
`1704`	`1707`	`*this << getIDAndType(BBI->getOperand());`
`1705`	`1708`	`}`
`1706`	`1709`
`@@ -2074,6 +2077,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {`
`2074`	`2077`	`*this << "[lexical] ";`
`2075`	`2078`	`if (I->hasPointerEscape())`
`2076`	`2079`	`*this << "[pointer_escape] ";`
	`2080`	`+ if (I->isFromVarDecl())`
	`2081`	`+ *this << "[var_decl] ";`
`2077`	`2082`	`*this << getIDAndType(I->getOperand());`
`2078`	`2083`	`}`
`2079`	`2084`