Serialize SIL forwarding ownership on terminators.

atrick · atrick · commit 33fecc9b2161 · 2021-09-07T10:20:14.000-07:00
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1073,6 +1073,11 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   ApplyOptions ApplyOpts;
   ArrayRef<uint64_t> ListOfValues;
   SILLocation Loc = RegularLocation(SLoc);
+  ValueOwnershipKind forwardingOwnership(OwnershipKind::Any);
+  auto decodeValueOwnership = [](unsigned field){
+    // Invalid/Any ownership is never encoded.
+    return ValueOwnershipKind(field+1);
+  };
 
   switch (RecordKind) {
   default:
@@ -1111,6 +1116,14 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     SILOneTypeValuesLayout::readRecord(scratch, RawOpCode, TyID, TyCategory,
                                        ListOfValues);
     break;
+  case SIL_ONE_TYPE_OWNERSHIP_VALUES: {
+    unsigned ownershipField;
+    SILOneTypeOwnershipValuesLayout::readRecord(scratch, RawOpCode,
+                                                ownershipField, TyID,
+                                                TyCategory, ListOfValues);
+    forwardingOwnership = decodeValueOwnership(ownershipField);
+    break;
+  }
   case SIL_TWO_OPERANDS:
     SILTwoOperandsLayout::readRecord(scratch, RawOpCode, Attr,
                                      TyID, TyCategory, ValID,
@@ -1941,7 +1954,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   }
   case SILInstructionKind::UncheckedOwnershipConversionInst: {
     auto Ty = MF->getType(TyID);
-    auto ResultKind = ValueOwnershipKind(Attr);
+    auto ResultKind = decodeValueOwnership(Attr);
     ResultInst = Builder.createUncheckedOwnershipConversion(
         Loc,
         getLocalValue(ValID, getSILType(Ty, (SILValueCategory)TyCategory, Fn)),
@@ -2252,10 +2265,13 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
       CaseBBs.push_back( {cast<EnumElementDecl>(MF->getDecl(ListOfValues[I])),
                             getBBForReference(Fn, ListOfValues[I+1])} );
     }
-    if (OpCode == SILInstructionKind::SwitchEnumInst)
-      ResultInst = Builder.createSwitchEnum(Loc, Cond, DefaultBB, CaseBBs);
-    else
+    if (OpCode == SILInstructionKind::SwitchEnumInst) {
+      ResultInst = Builder.createSwitchEnum(Loc, Cond, DefaultBB, CaseBBs,
+                                            None, ProfileCounter(),
+                                            forwardingOwnership);
+    } else {
       ResultInst = Builder.createSwitchEnumAddr(Loc, Cond, DefaultBB, CaseBBs);
+    }
     break;
   }
   case SILInstructionKind::SelectEnumInst:
@@ -2520,7 +2536,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
 
     ResultInst =
         Builder.createCheckedCastBranch(Loc, isExact, op, targetLoweredType,
-                                        targetFormalType, successBB, failureBB);
+                                        targetFormalType, successBB, failureBB,
+                                        forwardingOwnership);
     break;
   }
   case SILInstructionKind::CheckedCastValueBranchInst: {
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -56,7 +56,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 = 625; // is concurrency checked?
+const uint16_t SWIFTMODULE_VERSION_MINOR = 626; // switch & checkcast ownership
 
 /// 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
@@ -28,6 +28,7 @@ using ValueIDField = DeclIDField;
 
 using SILInstOpCodeField = BCFixed<8>;
 using SILTypeCategoryField = BCFixed<2>;
+using SILValueOwnershipField = BCFixed<2>;
 
 enum SILStringEncoding : uint8_t {
   SIL_UTF8,
@@ -126,6 +127,7 @@ namespace sil_block {
     SIL_ONE_OPERAND,
     SIL_ONE_TYPE_ONE_OPERAND,
     SIL_ONE_TYPE_VALUES,
+    SIL_ONE_TYPE_OWNERSHIP_VALUES,
     SIL_TWO_OPERANDS,
     SIL_TAIL_ADDR,
     SIL_INST_APPLY,
@@ -362,6 +364,16 @@ namespace sil_block {
     BCArray<ValueIDField>
   >;
 
+  // SIL instructions with one type, forwarding ownership, and a list of values.
+  // For OwnershipForwardingTermInst.
+  using SILOneTypeOwnershipValuesLayout = BCRecordLayout<
+    SIL_ONE_TYPE_OWNERSHIP_VALUES,
+    SILInstOpCodeField,
+    SILValueOwnershipField,
+    TypeIDField,
+    SILTypeCategoryField,
+    BCArray<ValueIDField>>;
+
   enum ApplyKind : unsigned {
     SIL_APPLY = 0,
     SIL_PARTIAL_APPLY,
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -870,6 +870,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(sil_block, SIL_ONE_OPERAND);
   BLOCK_RECORD(sil_block, SIL_ONE_TYPE_ONE_OPERAND);
   BLOCK_RECORD(sil_block, SIL_ONE_TYPE_VALUES);
+  BLOCK_RECORD(sil_block, SIL_ONE_TYPE_OWNERSHIP_VALUES);
   BLOCK_RECORD(sil_block, SIL_TWO_OPERANDS);
   BLOCK_RECORD(sil_block, SIL_TAIL_ADDR);
   BLOCK_RECORD(sil_block, SIL_INST_APPLY);
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -111,6 +111,11 @@ toStableDifferentiabilityKind(swift::DifferentiabilityKind kind) {
   llvm_unreachable("covered switch");
 }
 
+static unsigned encodeValueOwnership(ValueOwnershipKind ownership) {
+  assert(ownership.value > 0 && "invalid value ownership");
+  return ownership.value - 1;
+}
+
 namespace {
     /// Used to serialize the on-disk func hash table.
   class FuncTableInfo {
@@ -1213,10 +1218,11 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   }
   case SILInstructionKind::SwitchEnumInst:
   case SILInstructionKind::SwitchEnumAddrInst: {
-    // Format: condition, a list of cases (EnumElementDecl + Basic Block ID),
-    // default basic block ID. Use SILOneTypeValuesLayout: the type is
-    // for condition, the list has value for condition, hasDefault, default
-    // basic block ID, a list of (DeclID, BasicBlock ID).
+    // Format:
+    // - [ownership]
+    // - the type of the condition operand,
+    // - a list a values: operand, hasDefault, defaultBB,
+    //                    [EnumElementDecl,  Basic Block ID]*
     SwitchEnumTermInst SOI(&SI);
     assert(SOI);
     SmallVector<ValueID, 4> ListOfValues;
@@ -1234,11 +1240,22 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
       ListOfValues.push_back(S.addDeclRef(elt));
       ListOfValues.push_back(BasicBlockMap[dest]);
     }
-    SILOneTypeValuesLayout::emitRecord(
-        Out, ScratchRecord, SILAbbrCodes[SILOneTypeValuesLayout::Code],
-        (unsigned)SI.getKind(),
-        S.addTypeRef(SOI.getOperand()->getType().getASTType()),
-        (unsigned)SOI.getOperand()->getType().getCategory(), ListOfValues);
+    if (auto *switchEnum = dyn_cast<SwitchEnumInst>(&SI)) {
+      unsigned ownershipField =
+        encodeValueOwnership(switchEnum->getForwardingOwnershipKind());
+      SILOneTypeOwnershipValuesLayout::emitRecord(
+          Out, ScratchRecord,
+          SILAbbrCodes[SILOneTypeOwnershipValuesLayout::Code],
+          (unsigned)SI.getKind(), ownershipField,
+          S.addTypeRef(SOI.getOperand()->getType().getASTType()),
+          (unsigned)SOI.getOperand()->getType().getCategory(), ListOfValues);
+    } else {
+      SILOneTypeValuesLayout::emitRecord(
+          Out, ScratchRecord, SILAbbrCodes[SILOneTypeValuesLayout::Code],
+          (unsigned)SI.getKind(),
+          S.addTypeRef(SOI.getOperand()->getType().getASTType()),
+          (unsigned)SOI.getOperand()->getType().getCategory(), ListOfValues);
+    }
     break;
   }
   case SILInstructionKind::SelectEnumInst:
@@ -1400,7 +1417,7 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     else if (auto *RCI = dyn_cast<RefCountingInst>(&SI))
       Attr = RCI->isNonAtomic();
     else if (auto *UOCI = dyn_cast<UncheckedOwnershipConversionInst>(&SI)) {
-      Attr = unsigned(SILValue(UOCI).getOwnershipKind());
+      Attr = encodeValueOwnership(UOCI->getOwnershipKind());
     } else if (auto *IEC = dyn_cast<IsEscapingClosureInst>(&SI)) {
       Attr = IEC->getVerificationType();
     } else if (auto *HTE = dyn_cast<HopToExecutorInst>(&SI)) {
@@ -2153,12 +2170,14 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
       BasicBlockMap[CBI->getSuccessBB()],
       BasicBlockMap[CBI->getFailureBB()]
     };
-
-    SILOneTypeValuesLayout::emitRecord(Out, ScratchRecord,
-             SILAbbrCodes[SILOneTypeValuesLayout::Code], (unsigned)SI.getKind(),
-             S.addTypeRef(CBI->getTargetLoweredType().getASTType()),
-             (unsigned)CBI->getTargetLoweredType().getCategory(),
-             llvm::makeArrayRef(listOfValues));
+    unsigned ownershipField =
+      encodeValueOwnership(CBI->getForwardingOwnershipKind());
+    SILOneTypeOwnershipValuesLayout::emitRecord(
+        Out, ScratchRecord, SILAbbrCodes[SILOneTypeOwnershipValuesLayout::Code],
+        (unsigned)SI.getKind(), ownershipField,
+        S.addTypeRef(CBI->getTargetLoweredType().getASTType()),
+        (unsigned)CBI->getTargetLoweredType().getCategory(),
+        llvm::makeArrayRef(listOfValues));
     break;
   }
   case SILInstructionKind::CheckedCastValueBranchInst: {
@@ -2744,6 +2763,7 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   registerSILAbbr<SILOneTypeOneOperandLayout>();
   registerSILAbbr<SILInitExistentialLayout>();
   registerSILAbbr<SILOneTypeValuesLayout>();
+  registerSILAbbr<SILOneTypeOwnershipValuesLayout>();
   registerSILAbbr<SILTwoOperandsLayout>();
   registerSILAbbr<SILTwoOperandsExtraAttributeLayout>();
   registerSILAbbr<SILTailAddrLayout>();
diff --git a/test/SIL/Serialization/forwarding_ownership.sil b/test/SIL/Serialization/forwarding_ownership.sil
@@ -0,0 +1,60 @@
+// First parse this and then emit a *.sib. Then read in the *.sib, then recreate
+// RUN: %empty-directory(%t)
+// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name temp
+// RUN: %target-sil-opt %t/tmp.sib -o %t/tmp.2.sib -module-name temp
+// RUN: %target-sil-opt %t/tmp.2.sib -module-name temp | %FileCheck %s
+
+import Builtin
+
+enum FakeOptional<T> {
+case none
+case some(T)
+}
+
+class Klass {
+}
+class SubKlass : Klass {
+}
+
+// CHECK-LABEL: sil [ossa] @switch_test : $@convention(thin) () -> () {
+// CHECK: switch_enum {{.*}}, forwarding: @guaranteed
+// CHECK-LABEL: } // end sil function 'switch_test'
+sil [ossa] @switch_test : $@convention(thin) () -> () {
+  %none = enum $FakeOptional<Klass>, #FakeOptional.none
+  switch_enum %none : $FakeOptional<Klass>, case #FakeOptional.some!enumelt:bb1, case #FakeOptional.none!enumelt:bb2, forwarding: @guaranteed
+
+bb1(%arg : @guaranteed $Klass):
+  br bb3
+
+bb2:
+  br bb3
+
+bb3:
+  %8 = tuple ()
+  return %8 : $()
+}
+
+// Test checked_cast_br ownership forwarding.
+//
+// Also test unchecked_ownership_conversion @none serialization (@none
+// is the highest value ownership encoding).
+//
+// CHECK-LABEL: sil [ossa] @checked_cast_test : $@convention(thin) (@owned Klass) -> () {
+// CHECK: checked_cast_br {{.*}}, forwarding: @guaranteed
+// CHECK-LABEL: } // end sil function 'checked_cast_test'
+sil [ossa] @checked_cast_test : $@convention(thin) (@owned Klass) -> () {
+bb0(%0 : @owned $Klass):
+  %trivial = unchecked_ownership_conversion %0 : $Klass, @owned to @none
+  checked_cast_br %trivial : $Klass to SubKlass, bb1, bb2, forwarding: @guaranteed
+
+bb1(%arg1 : @guaranteed $SubKlass):
+  br bb3
+
+bb2(%arg2: @guaranteed $Klass):
+  br bb3
+
+bb3:
+  destroy_value %0 : $Klass
+  %8 = tuple ()
+  return %8 : $()
+}
