Merge pull request #68792 from atrick/fix-forwarding-operand

Fix ForwardingInstruction::getSingleForwardingOperand

Author: atrick

include/swift/SIL/InstWrappers.h

@@ -69,6 +69,8 @@ struct LoadOperation {
 };
 
 /// A wrapper type for writing generic code against conversion instructions.
+///
+/// Forwards a single operand in first operand position to a single result. 
 struct ConversionOperation {
   SingleValueInstruction *inst = nullptr;
 
@@ -259,19 +261,33 @@ class ForwardingOperation {
     case SILInstructionKind::LinearFunctionInst:
     case SILInstructionKind::DifferentiableFunctionInst:
       return nullptr;
+    case SILInstructionKind::MarkDependenceInst:
+      return &forwardingInst->getOperandRef(MarkDependenceInst::Value);
+    case SILInstructionKind::RefToBridgeObjectInst:
+      return
+        &forwardingInst->getOperandRef(RefToBridgeObjectInst::ConvertedOperand);
+    case SILInstructionKind::TuplePackExtractInst:
+      return &forwardingInst->getOperandRef(TuplePackExtractInst::TupleOperand);
+    case SILInstructionKind::SelectEnumInst:
+      // ignore trailing case operands
+      return &forwardingInst->getOperandRef(0);
     default:
-      if (forwardingInst->getNumRealOperands() == 0) {
+      int numRealOperands = forwardingInst->getNumRealOperands();
+      if (numRealOperands == 0) {
         // This can happen with enum instructions that have no payload.
         return nullptr;
       }
+      assert(numRealOperands == 1);
       return &forwardingInst->getOperandRef(0);
     }
   }
 
   ArrayRef<Operand> getForwardedOperands() const {
+    // Some instructions have multiple real operands but only forward one.
     if (auto *singleForwardingOp = getSingleForwardingOperand()) {
       return *singleForwardingOp;
     }
+    // All others forward all operands (for enum, this may be zero operands).
     return forwardingInst->getAllOperands();
   }
 

include/swift/SIL/SILInstruction.h

@@ -5711,6 +5711,10 @@ class RefToBridgeObjectInst
                              OwnershipForwardingSingleValueInstruction> {
   friend SILBuilder;
 
+public:
+  enum { ConvertedOperand = 0, MaskOperand = 1 };
+
+private:
   FixedOperandList<2> Operands;
   RefToBridgeObjectInst(SILDebugLocation DebugLoc, SILValue ConvertedValue,
                         SILValue MaskValue, SILType BridgeObjectTy,

lib/SIL/Utils/InstWrappers.cpp

@@ -54,6 +54,7 @@ bool ForwardingOperation::hasSameRepresentation() const {
   case SILInstructionKind::SelectEnumInst:
   case SILInstructionKind::StructExtractInst:
   case SILInstructionKind::TupleExtractInst:
+  case SILInstructionKind::TuplePackExtractInst:
     return true;
   }
 }
@@ -94,4 +95,4 @@ bool ForwardingOperation::visitForwardedValues(
     assert(args.size() == 1 && "Transforming terminator with multiple args?!");
     return visitor(args[0]);
   });
-}
+}