Merge pull request #82804 from eeckstein/simplify_negated_comparisons

InstructionSimplification: simplify negated integer comparisons

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -12,7 +12,7 @@
 
 import SIL
 
-extension BuiltinInst : OnoneSimplifiable {
+extension BuiltinInst : OnoneSimplifiable, SILCombineSimplifiable {
   func simplify(_ context: SimplifyContext) {
     switch id {
       case .IsConcrete:
@@ -53,6 +53,8 @@ extension BuiltinInst : OnoneSimplifiable {
         constantFoldIntegerEquality(isEqual: true, context)
       case .ICMP_NE:
         constantFoldIntegerEquality(isEqual: false, context)
+      case .Xor:
+        simplifyNegation(context)
       default:
         if let literal = constantFold(context) {
           uses.replaceAll(with: literal, context)
@@ -165,6 +167,11 @@ private extension BuiltinInst {
     case .Sizeof:
       value = ty.getStaticSize(context: context)
     case .Strideof:
+      if isUsedAsStrideOfIndexRawPointer(context) {
+        // Constant folding `stride` would prevent index_raw_pointer simplification.
+        // See `simplifyIndexRawPointer` in SimplifyPointerToAddress.swift.
+        return
+      }
       value = ty.getStaticStride(context: context)
     case .Alignof:
       value = ty.getStaticAlignment(context: context)
@@ -181,7 +188,33 @@ private extension BuiltinInst {
     uses.replaceAll(with: literal, context)
     context.erase(instruction: self)
   }
-  
+
+  private func isUsedAsStrideOfIndexRawPointer(_ context: SimplifyContext) -> Bool {
+    var worklist = ValueWorklist(context)
+    defer { worklist.deinitialize() }
+    worklist.pushIfNotVisited(self)
+    while let v = worklist.pop() {
+      for use in v.uses {
+        switch use.instruction {
+        case let builtin as BuiltinInst:
+          switch builtin.id {
+          case .SMulOver, .TruncOrBitCast, .SExtOrBitCast, .ZExtOrBitCast:
+            worklist.pushIfNotVisited(builtin)
+          default:
+            break
+          }
+        case let tupleExtract as TupleExtractInst where tupleExtract.fieldIndex == 0:
+          worklist.pushIfNotVisited(tupleExtract)
+        case is IndexRawPointerInst:
+          return true
+        default:
+          break
+        }
+      }
+    }
+    return false
+  }
+
   func optimizeArgumentToThinMetatype(argument: Int, _ context: SimplifyContext) {
     let type: Type
 
@@ -224,6 +257,53 @@ private extension BuiltinInst {
     }
     return false
   }
+
+  /// Replaces a builtin "xor", which negates its operand comparison
+  /// ```
+  ///   %3 = builtin "cmp_slt_Int64"(%1, %2) : $Builtin.Int1
+  ///   %4 = integer_literal $Builtin.Int1, -1
+  ///   %5 = builtin "xor_Int1"(%3, %4) : $Builtin.Int1
+  /// ```
+  /// with the negated comparison
+  /// ```
+  ///   %5 = builtin "cmp_ge_Int64"(%1, %2) : $Builtin.Int1
+  /// ```
+  func simplifyNegation(_ context: SimplifyContext) {
+    assert(id == .Xor)
+    guard let one = arguments[1] as? IntegerLiteralInst,
+          let oneValue = one.value,
+          oneValue == -1,
+          let lhsBuiltin = arguments[0] as? BuiltinInst,
+          lhsBuiltin.type.isBuiltinInteger,
+          let negatedBuiltinName = lhsBuiltin.negatedComparisonBuiltinName
+    else {
+      return
+    }
+
+    let builder = Builder(before: lhsBuiltin, context)
+    let negated = builder.createBuiltinBinaryFunction(name: negatedBuiltinName,
+        operandType: lhsBuiltin.arguments[0].type,
+        resultType: lhsBuiltin.type,
+        arguments: Array(lhsBuiltin.arguments))
+    self.replace(with: negated, context)
+  }
+
+  private var negatedComparisonBuiltinName: String? {
+    switch id {
+    case .ICMP_EQ:  return "cmp_ne"
+    case .ICMP_NE:  return "cmp_eq"
+    case .ICMP_SLE: return "cmp_sgt"
+    case .ICMP_SLT: return "cmp_sge"
+    case .ICMP_SGE: return "cmp_slt"
+    case .ICMP_SGT: return "cmp_sle"
+    case .ICMP_ULE: return "cmp_ugt"
+    case .ICMP_ULT: return "cmp_uge"
+    case .ICMP_UGE: return "cmp_ult"
+    case .ICMP_UGT: return "cmp_ule"
+    default:
+      return nil
+    }
+  }
 }
 
 private extension Value {

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -111,6 +111,7 @@ private func registerSwiftPasses() {
   // Instruction passes
   registerForSILCombine(BeginBorrowInst.self,      { run(BeginBorrowInst.self, $0) })
   registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })
+  registerForSILCombine(BuiltinInst.self,          { run(BuiltinInst.self, $0) })
   registerForSILCombine(FixLifetimeInst.self,      { run(FixLifetimeInst.self, $0) })
   registerForSILCombine(GlobalValueInst.self,      { run(GlobalValueInst.self, $0) })
   registerForSILCombine(StrongRetainInst.self,     { run(StrongRetainInst.self, $0) })

lib/SILOptimizer/LoopTransforms/BoundsCheckOpts.cpp

@@ -353,6 +353,11 @@ static bool isSignedLessEqual(SILValue Start, SILValue End, SILBasicBlock &BB) {
                                         m_Specific(Start), m_Specific(End)),
                             m_One())))
         return true;
+      // Try to match a cond_fail on "SGT Start, End".
+      if (match(CF->getOperand(),
+                m_ApplyInst(BuiltinValueKind::ICMP_SGT,
+                            m_Specific(Start), m_Specific(End))))
+        return true;
       // Try to match a cond_fail on "SLT End, Start".
       if (match(CF->getOperand(),
                 m_ApplyInst(BuiltinValueKind::ICMP_SLT, m_Specific(End),
@@ -368,6 +373,11 @@ static bool isSignedLessEqual(SILValue Start, SILValue End, SILBasicBlock &BB) {
                                           m_Specific(PreInclusiveEnd)),
                               m_One())))
           IsPreInclusiveEndLEQ = true;
+        if (match(CF->getOperand(),
+                  m_ApplyInst(BuiltinValueKind::ICMP_SGT,
+                              m_Specific(Start),
+                              m_Specific(PreInclusiveEnd))))
+          IsPreInclusiveEndLEQ = true;
         if (match(CF->getOperand(),
                   m_ApplyInst(BuiltinValueKind::ICMP_SLT,
                               m_Specific(PreInclusiveEnd), m_Specific(Start))))
@@ -379,6 +389,11 @@ static bool isSignedLessEqual(SILValue Start, SILValue End, SILBasicBlock &BB) {
                                           m_Specific(PreInclusiveEnd)),
                               m_One())))
           IsPreInclusiveEndGTEnd = true;
+        if (match(CF->getOperand(),
+                  m_ApplyInst(BuiltinValueKind::ICMP_SLE,
+                              m_Specific(End),
+                              m_Specific(PreInclusiveEnd))))
+          IsPreInclusiveEndGTEnd = true;
         if (IsPreInclusiveEndLEQ && IsPreInclusiveEndGTEnd)
           return true;
       }
@@ -910,6 +925,12 @@ static bool isComparisonKnownFalse(BuiltinInst *Builtin,
       IndVar.Cmp != BuiltinValueKind::ICMP_EQ)
     return false;
 
+  if (match(Builtin, m_ApplyInst(BuiltinValueKind::ICMP_SGE,
+                             m_Specific(IndVar.HeaderVal),
+                             m_Specific(IndVar.End)))) {
+    return true;
+  }
+
   // Pattern match a false condition patterns that we can detect and optimize:
   // Iteration count < 0 (start)
   // Iteration count + 1 <= 0 (start)

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -251,7 +251,6 @@ class SILCombiner :
   SILInstruction *visitPartialApplyInst(PartialApplyInst *AI);
   SILInstruction *visitBeginApplyInst(BeginApplyInst *BAI);
   SILInstruction *optimizeStringObject(BuiltinInst *BI);
-  SILInstruction *visitBuiltinInst(BuiltinInst *BI);
   SILInstruction *visitCondFailInst(CondFailInst *CFI);
   SILInstruction *visitRefToRawPointerInst(RefToRawPointerInst *RRPI);
   SILInstruction *visitUpcastInst(UpcastInst *UCI);

lib/SILOptimizer/SILCombiner/SILCombinerBuiltinVisitors.cpp

@@ -659,7 +659,7 @@ SILInstruction *SILCombiner::optimizeStringObject(BuiltinInst *BI) {
                                       setBits & andBits);
 }
 
-SILInstruction *SILCombiner::visitBuiltinInst(BuiltinInst *I) {
+SILInstruction *SILCombiner::legacyVisitBuiltinInst(BuiltinInst *I) {
   if (I->getBuiltinInfo().ID == BuiltinValueKind::CanBeObjCClass)
     return optimizeBuiltinCanBeObjCClass(I, Builder);
   if (I->getBuiltinInfo().ID == BuiltinValueKind::IsConcrete)

lib/SILOptimizer/SILCombiner/Simplifications.def

@@ -54,6 +54,7 @@ INSTRUCTION_SIMPLIFICATION(UncheckedEnumDataInst)
 INSTRUCTION_SIMPLIFICATION(WitnessMethodInst)
 INSTRUCTION_SIMPLIFICATION(EndCOWMutationAddrInst)
 INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(AllocStackInst)
+INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(BuiltinInst)
 INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(UnconditionalCheckedCastInst)
 INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(ApplyInst)
 INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(TryApplyInst)

test/Frontend/OptimizationOptions-with-stdlib-checks.swift

@@ -104,8 +104,7 @@ func test_partial_safety_check(x: Int, y: Int) -> Int {
 // In release mode keep succinct library precondition checks (trap).
 // RELEASE-LABEL: sil hidden @$s19OptimizationOptions22testprecondition_check1x1yS2i_SitF : $@convention(thin) (Int, Int) -> Int {
 // RELEASE-NOT:  "Fatal error"
-// RELEASE:  %[[V2:.+]] = builtin "xor_Int1"(%{{.+}}, %{{.+}})
-// RELEASE:  cond_fail %[[V2]]
+// RELEASE:  cond_fail %{{[0-9]}}, "precondition failure"
 // RELEASE:  return
 
 // In unchecked mode remove library precondition checks.

test/Frontend/OptimizationOptions-without-stdlib-checks.swift

@@ -101,8 +101,7 @@ func test_partial_safety_check(x: Int, y: Int) -> Int {
 // In release mode keep succinct library precondition checks (trap).
 // RELEASE-LABEL: sil hidden @$s19OptimizationOptions22testprecondition_check1x1yS2i_SitF : $@convention(thin) (Int, Int) -> Int {
 // RELEASE-NOT:  "Fatal error"
-// RELEASE:  %[[V2:.+]] = builtin "xor_Int1"(%{{.+}}, %{{.+}})
-// RELEASE:  cond_fail %[[V2]]
+// RELEASE:  cond_fail %{{[0-9]}}, "precondition failure"
 // RELEASE:  return
 
 // In unchecked mode remove library precondition checks.