SILCombine: peephole to propagate resilient enum cases

Basically the pattern to optimize is:
    inject_enum_addr %stackloc, #SomeCase
    switch_enum_addr %stackloc ...

This works even if the enum is resilient and the case does not have a payload. As long as we don't have opaque values in SIL we need this peephole to optimize the pattern.
This change fixes the code generation for Float.rounded().

rdar://problem/46353885

Author: eeckstein

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -106,23 +106,91 @@ SILCombiner::visitAllocExistentialBoxInst(AllocExistentialBoxInst *AEBI) {
   return nullptr;
 }
 
+/// Return the enum case injected by an inject_enum_addr if it is the only
+/// instruction which writes to \p Addr.
+static EnumElementDecl *getInjectEnumCaseTo(SILValue Addr) {
+  while (true) {
+    // For everything else than an alloc_stack we cannot easily prove that we
+    // see all writes.
+    if (!isa<AllocStackInst>(Addr))
+      return nullptr;
+
+    SILInstruction *WritingInst = nullptr;
+    int NumWrites = 0;
+    for (auto *Use : getNonDebugUses(Addr)) {
+      SILInstruction *User = Use->getUser();
+      switch (User->getKind()) {
+        // Handle a very narrow set of known not harmful instructions.
+        case swift::SILInstructionKind::DestroyAddrInst:
+        case swift::SILInstructionKind::DeallocStackInst:
+        case swift::SILInstructionKind::SwitchEnumAddrInst:
+          break;
+        case swift::SILInstructionKind::ApplyInst:
+        case swift::SILInstructionKind::TryApplyInst: {
+          // Check if the addr is only passed to in_guaranteed arguments.
+          FullApplySite AI(User);
+          for (Operand &Op : AI.getArgumentOperands()) {
+            if (Op.get() == Addr &&
+                AI.getArgumentConvention(Op) !=
+                  SILArgumentConvention::Indirect_In_Guaranteed)
+              return nullptr;
+          }
+          break;
+        }
+        case swift::SILInstructionKind::InjectEnumAddrInst:
+          WritingInst = User;
+          ++NumWrites;
+          break;
+        case swift::SILInstructionKind::CopyAddrInst:
+          if (Addr == cast<CopyAddrInst>(User)->getDest()) {
+            WritingInst = User;
+            ++NumWrites;
+          }
+          break;
+        default:
+          return nullptr;
+      }
+    }
+    if (NumWrites != 1)
+      return nullptr;
+    if (auto *IEA = dyn_cast<InjectEnumAddrInst>(WritingInst))
+      return IEA->getElement();
+
+    // In case of a copy_addr continue with the source of the copy.
+    Addr = dyn_cast<CopyAddrInst>(WritingInst)->getSrc();
+  }
+}
+
 SILInstruction *SILCombiner::visitSwitchEnumAddrInst(SwitchEnumAddrInst *SEAI) {
+  // Convert switch_enum_addr -> br
+  // if the only thing which writes to the address is an inject_enum_addr.
+  SILValue Addr = SEAI->getOperand();
+  if (EnumElementDecl *EnumCase = getInjectEnumCaseTo(Addr)) {
+    SILBasicBlock *Dest = SEAI->getCaseDestination(EnumCase);
+    // If the only instruction which writes to Addr is an inject_enum_addr we
+    // know that there cannot be an enum payload.
+    assert(Dest->getNumArguments() == 0 &&
+           "didn't expect a payload argument");
+    Builder.createBranch(SEAI->getLoc(), Dest);
+    return eraseInstFromFunction(*SEAI);
+  }
+
+  SILType Ty = Addr->getType();
+  if (!Ty.isLoadable(SEAI->getModule()))
+    return nullptr;
+
   // Promote switch_enum_addr to switch_enum if the enum is loadable.
   //   switch_enum_addr %ptr : $*Optional<SomeClass>, case ...
   //     ->
   //   %value = load %ptr
   //   switch_enum %value
-  SILType Ty = SEAI->getOperand()->getType();
-  if (!Ty.isLoadable(SEAI->getModule()))
-    return nullptr;
-
   SmallVector<std::pair<EnumElementDecl*, SILBasicBlock*>, 8> Cases;
   for (int i = 0, e = SEAI->getNumCases(); i < e; ++i)
     Cases.push_back(SEAI->getCase(i));
 
   Builder.setCurrentDebugScope(SEAI->getDebugScope());
   SILBasicBlock *Default = SEAI->hasDefault() ? SEAI->getDefaultBB() : nullptr;
-  LoadInst *EnumVal = Builder.createLoad(SEAI->getLoc(), SEAI->getOperand(),
+  LoadInst *EnumVal = Builder.createLoad(SEAI->getLoc(), Addr,
                                          LoadOwnershipQualifier::Unqualified);
   Builder.createSwitchEnum(SEAI->getLoc(), EnumVal, Default, Cases);
   return eraseInstFromFunction(*SEAI);

test/SILOptimizer/fp_rounding.swift

@@ -0,0 +1,30 @@
+// RUN: %target-swift-frontend -parse-as-library -O -emit-sil  %s | %FileCheck %s
+// REQUIRES: swift_stdlib_no_asserts,optimized_stdlib,CPU=x86_64
+
+// This is an end-to-end test to ensure that the optimizer can propagate
+// resilient enum cases (FloatingPointRoundingRule) and produces optimal
+// code for Float.rounded().
+
+// CHECK-LABEL: sil @{{.*}}propagate_roundingmode
+// CHECK:      bb0:
+// CHECK-NEXT:   %0 = integer_literal {{.*}}, 0
+// CHECK-NEXT:   %1 = struct $Int (%0 {{.*}})
+// CHECK-NEXT:   return %1
+public func propagate_roundingmode() -> Int {
+  let rm = FloatingPointRoundingRule.toNearestOrEven
+  switch rm {
+    case .toNearestOrAwayFromZero:
+      return 1
+    default:
+      return 0
+  }
+}
+
+// CHECK-LABEL: sil @{{.*}}round_floating_point
+// CHECK: bb0({{.*}}):
+// CHECK:   [[R:%[0-9]+]] = builtin "int_round{{.*}}"
+// CHECK:   [[F:%[0-9]+]] = struct $Float ([[R]]
+// CHECK:   return [[F]]
+public func round_floating_point(_ x: Float) -> Float {
+  return x.rounded()
+}

test/SILOptimizer/sil_combine.sil

@@ -2106,6 +2106,36 @@ bb3:
   return %2 : $()
 }
 
+// CHECK-LABEL: sil @resilient_enum_case_propagation
+// CHECK: bb0:
+// CHECK:   br bb2
+// CHECK: bb1:
+// CHECK:   return
+sil @resilient_enum_case_propagation : $@convention(thin) () -> Builtin.Int64 {
+bb0:
+  %0 = alloc_stack $FloatingPointRoundingRule
+  inject_enum_addr %0 : $*FloatingPointRoundingRule, #FloatingPointRoundingRule.toNearestOrEven!enumelt
+  %2 = alloc_stack $FloatingPointRoundingRule
+  copy_addr %0 to [initialization] %2 : $*FloatingPointRoundingRule
+  destroy_addr %0 : $*FloatingPointRoundingRule
+  switch_enum_addr %2 : $*FloatingPointRoundingRule, case #FloatingPointRoundingRule.toNearestOrAwayFromZero!enumelt: bb1, default bb2
+
+bb1:
+  %6 = integer_literal $Builtin.Int64, 1
+  br bb3(%6 : $Builtin.Int64)
+
+bb2:
+  destroy_addr %2 : $*FloatingPointRoundingRule
+  %9 = integer_literal $Builtin.Int64, 0
+  br bb3(%9 : $Builtin.Int64)
+
+bb3(%11 : $Builtin.Int64):
+  dealloc_stack %2 : $*FloatingPointRoundingRule
+  dealloc_stack %0 : $*FloatingPointRoundingRule
+  return %11 : $Builtin.Int64
+}
+
+
 @objc(XX) protocol XX {
 }
 

validation-test/Evolution/test_backward_deploy_enum.swift

@@ -5,7 +5,7 @@ import StdlibUnittest
 import backward_deploy_enum
 
 // <rdar://problem/46438568>
-// XFAIL: *
+// REQUIRES: rdar46438568
 
 var BackwardDeployEnumTest = TestSuite("BackwardDeployEnum")