Merge pull request #39574 from atrick/ossa-selectvalue

Fix SelectValue for OSSA

Author: atrick

include/swift/SIL/SILBuilder.h

@@ -1526,18 +1526,9 @@ class SILBuilder {
   SelectValueInst *createSelectValue(
       SILLocation Loc, SILValue Operand, SILType Ty, SILValue DefaultResult,
       ArrayRef<std::pair<SILValue, SILValue>> CaseValuesAndResult) {
-    return createSelectValue(Loc, Operand, Ty, DefaultResult,
-                             CaseValuesAndResult, Operand.getOwnershipKind());
-  }
-
-  SelectValueInst *
-  createSelectValue(SILLocation Loc, SILValue Operand, SILType Ty,
-                    SILValue DefaultResult,
-                    ArrayRef<std::pair<SILValue, SILValue>> CaseValuesAndResult,
-                    ValueOwnershipKind forwardingOwnershipKind) {
-    return insert(SelectValueInst::create(
-        getSILDebugLocation(Loc), Operand, Ty, DefaultResult,
-        CaseValuesAndResult, getModule(), forwardingOwnershipKind));
+    return insert(SelectValueInst::create(getSILDebugLocation(Loc), Operand, Ty,
+                                          DefaultResult, CaseValuesAndResult,
+                                          getModule()));
   }
 
   TupleExtractInst *createTupleExtract(SILLocation Loc, SILValue Operand,

include/swift/SIL/SILCloner.h

@@ -2815,10 +2815,7 @@ SILCloner<ImplClass>::visitSelectValueInst(SelectValueInst *Inst) {
   recordClonedInstruction(
       Inst, getBuilder().createSelectValue(
                 getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
-                getOpType(Inst->getType()), DefaultResult, CaseResults,
-                getBuilder().hasOwnership()
-                    ? Inst->getForwardingOwnershipKind()
-                    : ValueOwnershipKind(OwnershipKind::None)));
+                getOpType(Inst->getType()), DefaultResult, CaseResults));
 }
 
 template <typename ImplClass>

include/swift/SIL/SILInstruction.h

@@ -1089,8 +1089,7 @@ class OwnershipForwardingMixin {
   }
 };
 
-/// A single value inst that forwards a static ownership from one (or all) of
-/// its operands.
+/// A single value inst that forwards a static ownership from its first operand.
 ///
 /// The ownership kind is set on construction and afterwards must be changed
 /// explicitly using setOwnershipKind().
@@ -6263,20 +6262,17 @@ class SelectEnumAddrInst final
 class SelectValueInst final
     : public InstructionBaseWithTrailingOperands<
           SILInstructionKind::SelectValueInst, SelectValueInst,
-          SelectInstBase<SelectValueInst, SILValue,
-                         FirstArgOwnershipForwardingSingleValueInst>> {
+          SelectInstBase<SelectValueInst, SILValue, SingleValueInstruction>> {
   friend SILBuilder;
 
   SelectValueInst(SILDebugLocation DebugLoc, SILValue Operand, SILType Type,
                   SILValue DefaultResult,
-                  ArrayRef<SILValue> CaseValuesAndResults,
-                  ValueOwnershipKind forwardingOwnershipKind);
+                  ArrayRef<SILValue> CaseValuesAndResults);
 
   static SelectValueInst *
   create(SILDebugLocation DebugLoc, SILValue Operand, SILType Type,
          SILValue DefaultValue,
-         ArrayRef<std::pair<SILValue, SILValue>> CaseValues, SILModule &M,
-         ValueOwnershipKind forwardingOwnershipKind);
+         ArrayRef<std::pair<SILValue, SILValue>> CaseValues, SILModule &M);
 
 public:
   std::pair<SILValue, SILValue>

lib/SIL/IR/OperandOwnership.cpp

@@ -170,7 +170,6 @@ OPERAND_OWNERSHIP(TrivialUse, ProjectBlockStorage)
 OPERAND_OWNERSHIP(TrivialUse, ProjectValueBuffer)
 OPERAND_OWNERSHIP(TrivialUse, RawPointerToRef)
 OPERAND_OWNERSHIP(TrivialUse, SelectEnumAddr)
-OPERAND_OWNERSHIP(TrivialUse, SelectValue)
 OPERAND_OWNERSHIP(TrivialUse, StructElementAddr)
 OPERAND_OWNERSHIP(TrivialUse, SwitchEnumAddr)
 OPERAND_OWNERSHIP(TrivialUse, SwitchValue)
@@ -388,6 +387,23 @@ OperandOwnershipClassifier::visitSelectEnumInst(SelectEnumInst *i) {
     /*allowUnowned*/true);
 }
 
+OperandOwnership
+OperandOwnershipClassifier::visitSelectValueInst(SelectValueInst *i) {
+  if (getValue() == i->getDefaultResult())
+    return OperandOwnership::ForwardingBorrow;
+
+  for (unsigned idx = 0, endIdx = i->getNumCases(); idx < endIdx; ++idx) {
+    SILValue casevalue;
+    SILValue result;
+    std::tie(casevalue, result) = i->getCase(idx);
+
+    if (getValue() == casevalue) {
+      return OperandOwnership::ForwardingBorrow;
+    }
+  }
+  return OperandOwnership::TrivialUse;
+}
+
 OperandOwnership OperandOwnershipClassifier::visitBranchInst(BranchInst *bi) {
   ValueOwnershipKind destBlockArgOwnershipKind =
       bi->getDestBB()->getArgument(getOperandIndex())->getOwnershipKind();

lib/SIL/IR/SILInstructions.cpp

@@ -1777,17 +1777,15 @@ SwitchValueInst *SwitchValueInst::create(
 
 SelectValueInst::SelectValueInst(SILDebugLocation DebugLoc, SILValue Operand,
                                  SILType Type, SILValue DefaultResult,
-                                 ArrayRef<SILValue> CaseValuesAndResults,
-                                 ValueOwnershipKind forwardingOwnership)
+                                 ArrayRef<SILValue> CaseValuesAndResults)
     : InstructionBaseWithTrailingOperands(Operand, CaseValuesAndResults,
-                                          DebugLoc, Type, forwardingOwnership) {
-}
+                                          DebugLoc, Type) {}
 
 SelectValueInst *
 SelectValueInst::create(SILDebugLocation Loc, SILValue Operand, SILType Type,
                         SILValue DefaultResult,
                         ArrayRef<std::pair<SILValue, SILValue>> CaseValues,
-                        SILModule &M, ValueOwnershipKind forwardingOwnership) {
+                        SILModule &M) {
   // Allocate enough room for the instruction with tail-allocated data for all
   // the case values and the SILSuccessor arrays. There are `CaseBBs.size()`
   // SILValues and `CaseBBs.size() + (DefaultBB ? 1 : 0)` successors.
@@ -1802,8 +1800,8 @@ SelectValueInst::create(SILDebugLocation Loc, SILValue Operand, SILType Type,
 
   auto Size = totalSizeToAlloc<swift::Operand>(CaseValuesAndResults.size() + 1);
   auto Buf = M.allocateInst(Size, alignof(SelectValueInst));
-  return ::new (Buf) SelectValueInst(Loc, Operand, Type, DefaultResult,
-                                     CaseValuesAndResults, forwardingOwnership);
+  return ::new (Buf)
+      SelectValueInst(Loc, Operand, Type, DefaultResult, CaseValuesAndResults);
 }
 
 template <typename SELECT_ENUM_INST>

lib/SIL/IR/SILPrinter.cpp

@@ -2363,7 +2363,6 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << ", default " << Ctx.getID(SVI->getDefaultResult());
 
     *this << " : " << SVI->getType();
-    printForwardingOwnershipKind(SVI, SVI->getOperand());
   }
 
   void visitDynamicMethodBranchInst(DynamicMethodBranchInst *DMBI) {

lib/SIL/IR/ValueOwnership.cpp

@@ -167,6 +167,7 @@ CONSTANT_OWNERSHIP_INST(None, ExtractExecutor)
   }
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, StructExtract)
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, TupleExtract)
+CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, SelectValue)
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, DifferentiableFunctionExtract)
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, LinearFunctionExtract)
 // OpenExistentialValue opens the boxed value inside an existential
@@ -252,7 +253,6 @@ FORWARDING_OWNERSHIP_INST(BridgeObjectToRef)
 FORWARDING_OWNERSHIP_INST(ConvertFunction)
 FORWARDING_OWNERSHIP_INST(OpenExistentialRef)
 FORWARDING_OWNERSHIP_INST(RefToBridgeObject)
-FORWARDING_OWNERSHIP_INST(SelectValue)
 FORWARDING_OWNERSHIP_INST(Object)
 FORWARDING_OWNERSHIP_INST(Struct)
 FORWARDING_OWNERSHIP_INST(Tuple)