[SIL] Add dead_end flag to dealloc_box.

nate-chandler · nate-chandler · commit b150a484f273 · 2024-07-03T15:26:59.000-07:00
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -4179,7 +4179,7 @@ dealloc_box
 ```````````
 ::
 
-  sil-instruction ::= 'dealloc_box' sil-operand
+  sil-instruction ::= 'dealloc_box' '[dead_end]'? sil-operand
 
   dealloc_box %0 : $@box T
 
@@ -4192,6 +4192,9 @@ This does not destroy the boxed value. The contents of the
 value must have been fully uninitialized or destroyed before
 ``dealloc_box`` is applied.
 
+The optional ``dead_end`` attribute specifies that this instruction was created
+during lifetime completion and is eligible for deletion during OSSA lowering.
+
 project_box
 ```````````
 ::
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -2387,10 +2387,10 @@ class SILBuilder {
     return insert(new (getModule()) DeallocPartialRefInst(
         getSILDebugLocation(Loc), operand, metatype));
   }
-  DeallocBoxInst *createDeallocBox(SILLocation Loc,
-                                   SILValue operand) {
-    return insert(new (getModule()) DeallocBoxInst(
-        getSILDebugLocation(Loc), operand));
+  DeallocBoxInst *createDeallocBox(SILLocation Loc, SILValue operand,
+                                   IsDeadEnd_t isDeadEnd = IsntDeadEnd) {
+    return insert(new (getModule()) DeallocBoxInst(getSILDebugLocation(Loc),
+                                                   operand, isDeadEnd));
   }
   DeallocExistentialBoxInst *createDeallocExistentialBox(SILLocation Loc,
                                                          CanType concreteType,
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -3175,7 +3175,8 @@ SILCloner<ImplClass>::visitDeallocBoxInst(DeallocBoxInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
       Inst, getBuilder().createDeallocBox(getOpLocation(Inst->getLoc()),
-                                          getOpValue(Inst->getOperand())));
+                                          getOpValue(Inst->getOperand()),
+                                          Inst->isDeadEnd()));
 }
 
 template<typename ImplClass>
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -9463,8 +9463,19 @@ class DeallocBoxInst
 {
   friend SILBuilder;
 
-  DeallocBoxInst(SILDebugLocation DebugLoc, SILValue operand)
-      : UnaryInstructionBase(DebugLoc, operand) {}
+  USE_SHARED_UINT8;
+
+public:
+  IsDeadEnd_t isDeadEnd() const {
+    return IsDeadEnd_t(sharedUInt8().DeallocBoxInst.deadEnd);
+  }
+
+private:
+  DeallocBoxInst(SILDebugLocation DebugLoc, SILValue operand,
+                 IsDeadEnd_t isDeadEnd)
+      : UnaryInstructionBase(DebugLoc, operand) {
+    sharedUInt8().DeallocBoxInst.deadEnd = isDeadEnd;
+  }
 };
 
 /// Deallocate memory allocated for a boxed existential container created by
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -248,6 +248,9 @@ class alignas(8) SILNode :
                  fromVarDecl : 1,
                  fixed : 1);
 
+    SHARED_FIELD(DeallocBoxInst, uint8_t
+                 deadEnd : 1);
+
     SHARED_FIELD(CopyAddrInst, uint8_t
       isTakeOfSrc : 1,
       isInitializationOfDest : 1);
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -2649,6 +2649,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(DPI->getMetatype());
   }
   void visitDeallocBoxInst(DeallocBoxInst *DI) {
+    if (DI->isDeadEnd())
+      *this << "[dead_end] ";
     *this << getIDAndType(DI->getOperand());
   }
   void visitDestroyAddrInst(DestroyAddrInst *DI) {
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -4971,12 +4971,15 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     ResultVal = B.createDeallocPartialRef(InstLoc, Instance, Metatype);
     break;
   }
-    case SILInstructionKind::DeallocBoxInst:
-      if (parseTypedValueRef(Val, B) || parseSILDebugLocation(InstLoc, B))
-        return true;
+  case SILInstructionKind::DeallocBoxInst: {
+    bool isDeadEnd = false;
+    if (parseSILOptional(isDeadEnd, *this, "dead_end") ||
+        parseTypedValueRef(Val, B) || parseSILDebugLocation(InstLoc, B))
+      return true;
 
-      ResultVal = B.createDeallocBox(InstLoc, Val);
-      break;
+    ResultVal = B.createDeallocBox(InstLoc, Val, IsDeadEnd_t(isDeadEnd));
+    break;
+  }
     case SILInstructionKind::ValueMetatypeInst:
     case SILInstructionKind::ExistentialMetatypeInst: {
       SILType Ty;
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -3809,6 +3809,10 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     require(boxTy, "operand must be a @box type");
     require(DI->getOperand()->getType().isObject(),
             "operand must be an object");
+    if (DI->isDeadEnd()) {
+      require(getDeadEndBlocks().isDeadEnd(DI->getParentBlock()),
+              "a dead_end dealloc_box must be in a dead-end block");
+    }
   }
 
   void checkDestroyAddrInst(DestroyAddrInst *DI) {
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1455,14 +1455,18 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     ONETYPE_ONEOPERAND_INST(ExistentialMetatype)
     ONETYPE_ONEOPERAND_INST(ProjectExistentialBox)
 #undef ONETYPE_ONEOPERAND_INST
-  case SILInstructionKind::DeallocBoxInst:
+  case SILInstructionKind::DeallocBoxInst: {
     assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
            "Layout should be OneTypeOneOperand.");
+    IsDeadEnd_t isDeadEnd = IsDeadEnd_t(Attr & 0x1);
     ResultInst = Builder.createDeallocBox(
-        Loc, getLocalValue(Builder.maybeGetFunction(), ValID,
-                           getSILType(MF->getType(TyID2),
-                                      (SILValueCategory)TyCategory2, Fn)));
+        Loc,
+        getLocalValue(
+            Builder.maybeGetFunction(), ValID,
+            getSILType(MF->getType(TyID2), (SILValueCategory)TyCategory2, Fn)),
+        isDeadEnd);
     break;
+  }
   case SILInstructionKind::OpenExistentialAddrInst:
     assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
            "Layout should be OneTypeOneOperand.");
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 = 879; // dead_end flag on destroy_value
+const uint16_t SWIFTMODULE_VERSION_MINOR = 880; // dead_end flag on dealloc_box
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1036,9 +1036,9 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   }
   case SILInstructionKind::DeallocBoxInst: {
     auto DBI = cast<DeallocBoxInst>(&SI);
-    writeOneTypeOneOperandLayout(DBI->getKind(), 0,
-                                 DBI->getOperand()->getType(),
-                                 DBI->getOperand());
+    unsigned Attr = unsigned(DBI->isDeadEnd());
+    writeOneTypeOneOperandLayout(
+        DBI->getKind(), Attr, DBI->getOperand()->getType(), DBI->getOperand());
     break;
   }
   case SILInstructionKind::DeallocExistentialBoxInst: {
diff --git a/test/SIL/Parser/basic2.sil b/test/SIL/Parser/basic2.sil
@@ -385,3 +385,22 @@ bright:
   destroy_value [poison] [dead_end] %k4 : $Klass
   unreachable
 }
+
+// CHECK-LABEL: sil [ossa] @test_dealloc_box : {{.*}} {
+// CHECK:         dealloc_box
+// CHECK:         dealloc_box [dead_end]
+// CHECK-LABEL: } // end sil function 'test_dealloc_box'
+sil [ossa] @test_dealloc_box : $@convention(thin) () -> () {
+entry:
+  %b = alloc_box ${ var Klass }
+  cond_br undef, exit, die
+
+exit:
+  dealloc_box %b : ${ var Klass }
+  %retval = tuple()
+  return %retval : $()
+
+die:
+  dealloc_box [dead_end] %b : ${ var Klass }
+  unreachable
+}
diff --git a/test/SIL/Serialization/basic2.sil b/test/SIL/Serialization/basic2.sil
@@ -42,6 +42,29 @@ bb0(%0 : $*Builtin.NativeObject):
   return %9999 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @test_dealloc_box : {{.*}} {
+// CHECK:         cond_br undef, [[EXIT:bb[0-9]+]], [[DIE:bb[0-9]+]]
+// CHECK:       [[DIE]]:
+// CHECK:         dealloc_box [dead_end]
+// CHECK:         unreachable
+// CHECK:       [[EXIT]]:
+// CHECK:         dealloc_box
+// CHECK-LABEL: } // end sil function 'test_dealloc_box'
+sil [ossa] @test_dealloc_box : $@convention(thin) () -> () {
+entry:
+  %b = alloc_box ${ var C }
+  cond_br undef, exit, die
+
+exit:
+  dealloc_box %b : ${ var C }
+  %retval = tuple()
+  return %retval : $()
+
+die:
+  dealloc_box [dead_end] %b : ${ var C }
+  unreachable
+}
+
 // We don't serialize debug_value today... but we should.
 //
 // CHECK-LABEL: sil [ossa] @test_debug_value_alloc_stack_moved : $@convention(thin) (@owned Builtin.NativeObject) -> () {
diff --git a/test/SIL/cloning.sil b/test/SIL/cloning.sil
@@ -263,3 +263,29 @@ entry(%x : @owned $X):
   %res = apply %callee(%x) : $@convention(thin) (@owned X) -> ()
   return %res : $()
 }
+
+sil [ossa] [always_inline] @callee_dealloc_box : $@convention(thin) () -> () {
+entry:
+  %b = alloc_box ${ var X }
+  cond_br undef, exit, die
+
+exit:
+  dealloc_box %b : ${ var X }
+  %retval = tuple()
+  return %retval : $()
+
+die:
+  dealloc_box [dead_end] %b : ${ var X }
+  unreachable
+}
+
+// CHECK-LABEL: sil [ossa] @caller_dealloc_box : {{.*}} {
+// CHECK:         dealloc_box
+// CHECK:         dealloc_box [dead_end]
+// CHECK-LABEL: } // end sil function 'caller_dealloc_box'
+sil [ossa] @caller_dealloc_box : $@convention(thin) () -> () {
+entry:
+  %callee = function_ref @callee_dealloc_box : $@convention(thin) () -> ()
+  %res = apply %callee() : $@convention(thin) () -> ()
+  return %res : $()
+}
diff --git a/test/SIL/verifier_failures.sil b/test/SIL/verifier_failures.sil
@@ -31,3 +31,16 @@ entry(%c : @owned $C):
   %retval = tuple()
   return %retval : $()
 }
+
+// CHECK-LABEL: Begin Error in function dealloc_box_dead_end
+// CHECK:       SIL verification failed: a dead_end dealloc_box must be in a dead-end block
+// CHECK:       Verifying instruction:
+// CHECK:            [[BOX:%[^,]+]] = alloc_box
+// CHECK:       ->   dealloc_box [dead_end] [[BOX]]
+// CHECK-LABEL: End Error in function dealloc_box_dead_end
+sil [ossa] @dealloc_box_dead_end : $@convention(thin) () -> () {
+  %b = alloc_box ${ var C }
+  dealloc_box [dead_end] %b : ${ var C }
+  %retval = tuple()
+  return %retval : $()
+}

Original file line number	Diff line number	Diff line change
`@@ -3175,7 +3175,8 @@ SILCloner<ImplClass>::visitDeallocBoxInst(DeallocBoxInst *Inst) {`
`3175`	`3175`	`getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));`
`3176`	`3176`	`recordClonedInstruction(`
`3177`	`3177`	`Inst, getBuilder().createDeallocBox(getOpLocation(Inst->getLoc()),`
`3178`		`- getOpValue(Inst->getOperand())));`
	`3178`	`+ getOpValue(Inst->getOperand()),`
	`3179`	`+ Inst->isDeadEnd()));`
`3179`	`3180`	`}`
`3180`	`3181`
`3181`	`3182`	`template<typename ImplClass>`
Original file line number	Diff line number	Diff line change
`@@ -2649,6 +2649,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {`
`2649`	`2649`	`*this << getIDAndType(DPI->getMetatype());`
`2650`	`2650`	`}`
`2651`	`2651`	`void visitDeallocBoxInst(DeallocBoxInst *DI) {`
	`2652`	`+ if (DI->isDeadEnd())`
	`2653`	`+ *this << "[dead_end] ";`
`2652`	`2654`	`*this << getIDAndType(DI->getOperand());`
`2653`	`2655`	`}`
`2654`	`2656`	`void visitDestroyAddrInst(DestroyAddrInst *DI) {`