OwnershipUtils: check for SILInstructionKind instead of SILNodeKind

This resolves a FIXME.
Also, use `getDefiningInstruction()` instead of `getRepresentativeSILNodeInObject()`

NFC

Author: eeckstein

lib/SIL/Utils/OwnershipUtils.cpp

@@ -26,31 +26,29 @@ bool swift::isValueAddressOrTrivial(SILValue v) {
 }
 
 // These operations forward both owned and guaranteed ownership.
-//
-// FIXME: Should be implemented as a SILInstruction type check-cast.
-static bool isOwnershipForwardingValueKind(SILNodeKind kind) {
+static bool isOwnershipForwardingInstructionKind(SILInstructionKind kind) {
   switch (kind) {
-  case SILNodeKind::TupleInst:
-  case SILNodeKind::StructInst:
-  case SILNodeKind::EnumInst:
-  case SILNodeKind::DifferentiableFunctionInst:
-  case SILNodeKind::LinearFunctionInst:
-  case SILNodeKind::OpenExistentialRefInst:
-  case SILNodeKind::UpcastInst:
-  case SILNodeKind::UncheckedValueCastInst:
-  case SILNodeKind::UncheckedRefCastInst:
-  case SILNodeKind::ConvertFunctionInst:
-  case SILNodeKind::RefToBridgeObjectInst:
-  case SILNodeKind::BridgeObjectToRefInst:
-  case SILNodeKind::UnconditionalCheckedCastInst:
-  case SILNodeKind::UncheckedEnumDataInst:
-  case SILNodeKind::SelectEnumInst:
-  case SILNodeKind::SwitchEnumInst:
-  case SILNodeKind::CheckedCastBranchInst:
-  case SILNodeKind::DestructureStructInst:
-  case SILNodeKind::DestructureTupleInst:
-  case SILNodeKind::MarkDependenceInst:
-  case SILNodeKind::InitExistentialRefInst:
+  case SILInstructionKind::TupleInst:
+  case SILInstructionKind::StructInst:
+  case SILInstructionKind::EnumInst:
+  case SILInstructionKind::DifferentiableFunctionInst:
+  case SILInstructionKind::LinearFunctionInst:
+  case SILInstructionKind::OpenExistentialRefInst:
+  case SILInstructionKind::UpcastInst:
+  case SILInstructionKind::UncheckedValueCastInst:
+  case SILInstructionKind::UncheckedRefCastInst:
+  case SILInstructionKind::ConvertFunctionInst:
+  case SILInstructionKind::RefToBridgeObjectInst:
+  case SILInstructionKind::BridgeObjectToRefInst:
+  case SILInstructionKind::UnconditionalCheckedCastInst:
+  case SILInstructionKind::UncheckedEnumDataInst:
+  case SILInstructionKind::SelectEnumInst:
+  case SILInstructionKind::SwitchEnumInst:
+  case SILInstructionKind::CheckedCastBranchInst:
+  case SILInstructionKind::DestructureStructInst:
+  case SILInstructionKind::DestructureTupleInst:
+  case SILInstructionKind::MarkDependenceInst:
+  case SILInstructionKind::InitExistentialRefInst:
     return true;
   default:
     return false;
@@ -59,17 +57,17 @@ static bool isOwnershipForwardingValueKind(SILNodeKind kind) {
 
 // These operations forward guaranteed ownership, but don't necessarily forward
 // owned values.
-static bool isGuaranteedForwardingValueKind(SILNodeKind kind) {
+static bool isGuaranteedForwardingInstructionKind(SILInstructionKind kind) {
   switch (kind) {
-  case SILNodeKind::TupleExtractInst:
-  case SILNodeKind::StructExtractInst:
-  case SILNodeKind::DifferentiableFunctionExtractInst:
-  case SILNodeKind::LinearFunctionExtractInst:
-  case SILNodeKind::OpenExistentialValueInst:
-  case SILNodeKind::OpenExistentialBoxValueInst:
+  case SILInstructionKind::TupleExtractInst:
+  case SILInstructionKind::StructExtractInst:
+  case SILInstructionKind::DifferentiableFunctionExtractInst:
+  case SILInstructionKind::LinearFunctionExtractInst:
+  case SILInstructionKind::OpenExistentialValueInst:
+  case SILInstructionKind::OpenExistentialBoxValueInst:
     return true;
   default:
-    return isOwnershipForwardingValueKind(kind);
+    return isOwnershipForwardingInstructionKind(kind);
   }
 }
 
@@ -83,32 +81,34 @@ bool swift::canOpcodeForwardGuaranteedValues(SILValue value) {
         return true;
       }
 
-  auto *node = value->getRepresentativeSILNodeInObject();
-  bool result = isGuaranteedForwardingValueKind(node->getKind());
+  auto *inst = value->getDefiningInstruction();
+  if (!inst)
+    return false;
+
+  bool result = isGuaranteedForwardingInstructionKind(inst->getKind());
   if (result) {
-    assert(!isa<OwnedFirstArgForwardingSingleValueInst>(node));
-    assert(OwnershipForwardingMixin::isa(node));
+    assert(!isa<OwnedFirstArgForwardingSingleValueInst>(inst));
+    assert(OwnershipForwardingMixin::isa(inst));
   }
   return result;
 }
 
 bool swift::canOpcodeForwardGuaranteedValues(Operand *use) {
   auto *user = use->getUser();
-  auto kind = user->getKind();
-  bool result = isOwnershipForwardingValueKind(SILNodeKind(kind));
+  bool result = isOwnershipForwardingInstructionKind(user->getKind());
   if (result) {
     assert(!isa<GuaranteedFirstArgForwardingSingleValueInst>(user));
     assert(OwnershipForwardingMixin::isa(user));
   }
   return result;
 }
 
-static bool isOwnedForwardingValueKind(SILNodeKind kind) {
+static bool isOwnedForwardingValueKind(SILInstructionKind kind) {
   switch (kind) {
-  case SILNodeKind::MarkUninitializedInst:
+  case SILInstructionKind::MarkUninitializedInst:
     return true;
   default:
-    return isOwnershipForwardingValueKind(kind);
+    return isOwnershipForwardingInstructionKind(kind);
   }
 }
 
@@ -121,19 +121,21 @@ bool swift::canOpcodeForwardOwnedValues(SILValue value) {
         assert(OwnershipForwardingMixin::isa(predTerm));
         return true;
       }
-  auto *node = value->getRepresentativeSILNodeInObject();
-  bool result = isOwnedForwardingValueKind(node->getKind());
+  auto *inst = value->getDefiningInstruction();
+  if (!inst)
+    return false;
+
+  bool result = isOwnedForwardingValueKind(inst->getKind());
   if (result) {
-    assert(!isa<GuaranteedFirstArgForwardingSingleValueInst>(node));
-    assert(OwnershipForwardingMixin::isa(node));
+    assert(!isa<GuaranteedFirstArgForwardingSingleValueInst>(inst));
+    assert(OwnershipForwardingMixin::isa(inst));
   }
   return result;
 }
 
 bool swift::canOpcodeForwardOwnedValues(Operand *use) {
   auto *user = use->getUser();
-  auto kind = SILNodeKind(user->getKind());
-  bool result = isOwnershipForwardingValueKind(kind);
+  bool result = isOwnershipForwardingInstructionKind(user->getKind());
   if (result) {
     assert(OwnershipForwardingMixin::isa(user));
   }