Merge pull request #5714 from shajrawi/ins_combine

[SILOptimizer] Add support for new patterns in SILCombiner

Author: Joe Shajrawi

include/swift/SIL/SILBuilder.h

@@ -367,18 +367,21 @@ class SILBuilder {
     auto &C = getASTContext();
 
     llvm::SmallString<16> NameStr = Name;
-    if (auto BuiltinIntTy =
-            dyn_cast<BuiltinIntegerType>(OpdTy.getSwiftRValueType())) {
-      if (BuiltinIntTy == BuiltinIntegerType::getWordType(getASTContext())) {
-        NameStr += "_Word";
-      } else {
-        unsigned NumBits = BuiltinIntTy->getWidth().getFixedWidth();
-        NameStr += "_Int" + llvm::utostr(NumBits);
-      }
-    } else {
-      assert(OpdTy.getSwiftRValueType() == C.TheRawPointerType);
-      NameStr += "_RawPointer";
-    }
+    appendOperandTypeName(OpdTy, NameStr);
+    auto Ident = C.getIdentifier(NameStr);
+    return insert(BuiltinInst::create(getSILDebugLocation(Loc), Ident, ResultTy,
+                                      {}, Args, F));
+  }
+
+  // Create a binary function with the signature: OpdTy1, OpdTy2 -> ResultTy.
+  BuiltinInst *createBuiltinBinaryFunctionWithTwoOpTypes(
+      SILLocation Loc, StringRef Name, SILType OpdTy1, SILType OpdTy2,
+      SILType ResultTy, ArrayRef<SILValue> Args) {
+    auto &C = getASTContext();
+
+    llvm::SmallString<16> NameStr = Name;
+    appendOperandTypeName(OpdTy1, NameStr);
+    appendOperandTypeName(OpdTy2, NameStr);
     auto Ident = C.getIdentifier(NameStr);
     return insert(BuiltinInst::create(getSILDebugLocation(Loc), Ident,
                                       ResultTy, {}, Args, F));
@@ -1635,6 +1638,22 @@ class SILBuilder {
 
     BB->insert(InsertPt, TheInst);
   }
+
+  void appendOperandTypeName(SILType OpdTy, llvm::SmallString<16> &Name) {
+    auto &C = getASTContext();
+    if (auto BuiltinIntTy =
+            dyn_cast<BuiltinIntegerType>(OpdTy.getSwiftRValueType())) {
+      if (BuiltinIntTy == BuiltinIntegerType::getWordType(getASTContext())) {
+        Name += "_Word";
+      } else {
+        unsigned NumBits = BuiltinIntTy->getWidth().getFixedWidth();
+        Name += "_Int" + llvm::utostr(NumBits);
+      }
+    } else {
+      assert(OpdTy.getSwiftRValueType() == C.TheRawPointerType);
+      Name += "_RawPointer";
+    }
+  }
 };
 
 /// An wrapper on top of SILBuilder's constructor that automatically sets the

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -231,6 +231,13 @@ class SILCombiner :
   /// Instruction visitor helpers.
   SILInstruction *optimizeBuiltinCanBeObjCClass(BuiltinInst *AI);
 
+  // Optimize the "trunc_N1_M2" builtin. if N1 is a result of "zext_M1_*" and
+  // the following holds true: N1 > M1 and M2>= M1
+  SILInstruction *optimizeBuiltinTruncOrBitCast(BuiltinInst *I);
+
+  // Optimize the "zext_M2_M3" builtin. if M2 is a result of "zext_M1_M2"
+  SILInstruction *optimizeBuiltinZextOrBitCast(BuiltinInst *I);
+
   // Optimize the "cmp_eq_XXX" builtin. If \p NegateResult is true then negate
   // the result bit.
   SILInstruction *optimizeBuiltinCompareEq(BuiltinInst *AI, bool NegateResult);

lib/SILOptimizer/SILCombiner/SILCombinerBuiltinVisitors.cpp

@@ -89,6 +89,69 @@ SILInstruction *SILCombiner::optimizeBuiltinCanBeObjCClass(BuiltinInst *BI) {
   }
 }
 
+static unsigned getTypeWidth(SILType Ty) {
+  if (auto BuiltinIntTy =
+          dyn_cast<BuiltinIntegerType>(Ty.getSwiftRValueType())) {
+    if (BuiltinIntTy->isFixedWidth()) {
+      return BuiltinIntTy->getFixedWidth();
+    }
+  }
+  return 0;
+}
+
+SILInstruction *SILCombiner::optimizeBuiltinTruncOrBitCast(BuiltinInst *I) {
+  assert(I->getBuiltinInfo().ID == BuiltinValueKind::TruncOrBitCast &&
+         "BuiltinInst is not Trunc");
+  SILValue Op = I->getArguments()[0];
+  SILValue Source;
+  if (match(Op, m_ZExtOrBitCast(m_SILValue(Source)))) {
+    SILType ResultType = I->getType();
+    SILType SourceType = Source->getType();
+    SILType SourceTargetType = Op->getType();
+    unsigned ResultTypeWidth = getTypeWidth(ResultType);
+    unsigned SourceTypeWidth = getTypeWidth(SourceType);
+    unsigned SourceTargetTypeWidth = getTypeWidth(SourceTargetType);
+    if (ResultTypeWidth == 0 || SourceTypeWidth == 0 ||
+        SourceTargetTypeWidth == 0) {
+      // Not all types involved have fixed width
+      return nullptr;
+    }
+    if (SourceTargetTypeWidth <= SourceTypeWidth) {
+      return nullptr;
+    }
+    if (ResultTypeWidth < SourceTypeWidth) {
+      return nullptr;
+    }
+    // Reach here if and only if:
+    // SourceTargetTypeWidth > SourceTypeWidth and ResultTypeWidth >=
+    // SourceTypeWidth
+    auto *NI = Builder.createBuiltinBinaryFunctionWithTwoOpTypes(
+        I->getLoc(), "zextOrBitCast", Source->getType(), ResultType, ResultType,
+        Source);
+    replaceInstUsesWith(*I, NI);
+    return eraseInstFromFunction(*I);
+  }
+  return nullptr;
+}
+
+SILInstruction *SILCombiner::optimizeBuiltinZextOrBitCast(BuiltinInst *I) {
+  assert(I->getBuiltinInfo().ID == BuiltinValueKind::ZExtOrBitCast &&
+         "BuiltinInst is not ZExt");
+  SILValue Op = I->getArguments()[0];
+  SILValue Source;
+  if (match(Op, m_ZExtOrBitCast(m_SILValue(Source)))) {
+    SILType ResultType = I->getType();
+    // We can't extend to a size *smaller* than the source.
+    // As such, this transformation will always maintain correctness
+    auto *NI = Builder.createBuiltinBinaryFunctionWithTwoOpTypes(
+        I->getLoc(), "zextOrBitCast", Source->getType(), ResultType, ResultType,
+        Source);
+    replaceInstUsesWith(*I, NI);
+    return eraseInstFromFunction(*I);
+  }
+  return nullptr;
+}
+
 /// Optimize builtins which receive the same value in their first and second
 /// operand.
 static SILInstruction *optimizeBuiltinWithSameOperands(SILBuilder &Builder,
@@ -360,6 +423,13 @@ SILInstruction *SILCombiner::visitBuiltinInst(BuiltinInst *I) {
       I->getBuiltinInfo().ID == BuiltinValueKind::CopyArray)
     return optimizeBuiltinArrayOperation(I, Builder);
 
+  if (I->getBuiltinInfo().ID == BuiltinValueKind::TruncOrBitCast) {
+    return optimizeBuiltinTruncOrBitCast(I);
+  }
+  if (I->getBuiltinInfo().ID == BuiltinValueKind::ZExtOrBitCast) {
+    return optimizeBuiltinZextOrBitCast(I);
+  }
+
   if (I->getNumOperands() >= 2 && I->getOperand(0) == I->getOperand(1)) {
     // It's a builtin which has the same value in its first and second operand.
     auto *Replacement = optimizeBuiltinWithSameOperands(Builder, I, this);

test/SILOptimizer/sil_combine.sil

@@ -1318,6 +1318,45 @@ bb0(%0 : $Builtin.RawPointer, %1: $Builtin.Int64):
   return %11 : $Int32
 }
 
+// CHECK-LABEL: sil @trunc_of_zext : $@convention(thin) (Builtin.Int16) -> Builtin.Int32
+// CHECK-NOT: builtin "zextOrBitCast_Int16_Int64"
+// CHECK-NOT: builtin "truncOrBitCast_Int64_Int32"
+// CHECK: builtin "zextOrBitCast_Int16_Int32"
+// CHECK-NEXT: return
+sil @trunc_of_zext : $@convention(thin) (Builtin.Int16) -> Builtin.Int32 {
+bb0(%0 : $Builtin.Int16):
+  %zext = builtin "zextOrBitCast_Int16_Int64"(%0 : $Builtin.Int16) : $Builtin.Int64
+  %trunc = builtin "truncOrBitCast_Int64_Int32"(%zext : $Builtin.Int64) : $Builtin.Int32
+  return %trunc : $Builtin.Int32
+}
+
+// CHECK-LABEL: sil @zext_of_zext : $@convention(thin) (Builtin.Int16) -> Builtin.Int64
+// CHECK-NOT: builtin "zextOrBitCast_Int16_Int32"
+// CHECK-NOT: builtin "zextOrBitCast_Int32_Int64"
+// CHECK: builtin "zextOrBitCast_Int16_Int64"
+// CHECK-NEXT: return
+sil @zext_of_zext : $@convention(thin) (Builtin.Int16) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int16):
+  %zext1 = builtin "zextOrBitCast_Int16_Int32"(%0 : $Builtin.Int16) : $Builtin.Int32
+  %zext2 = builtin "zextOrBitCast_Int32_Int64"(%zext1 : $Builtin.Int32) : $Builtin.Int64
+  return %zext2 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @trunc_of_zext_then_zext : $@convention(thin) (Builtin.Int16) -> Builtin.Int16
+// CHECK-NOT: builtin "zextOrBitCast_Int16_Int64"
+// CHECK-NOT: builtin "truncOrBitCast_Int64_Int32"
+// CHECK-NOT: builtin "zextOrBitCast_Int32_Int64"
+// CHECK-NOT: builtin "truncOrBitCast_Int64_Int16"
+// CHECK: return
+sil @trunc_of_zext_then_zext : $@convention(thin) (Builtin.Int16) -> Builtin.Int16 {
+bb0(%0 : $Builtin.Int16):
+  %zext = builtin "zextOrBitCast_Int16_Int64"(%0 : $Builtin.Int16) : $Builtin.Int64
+  %trunc = builtin "truncOrBitCast_Int64_Int32"(%zext : $Builtin.Int64) : $Builtin.Int32
+  %zext2 = builtin "zextOrBitCast_Int32_Int64"(%trunc : $Builtin.Int32) : $Builtin.Int64
+  %trunc2 = builtin "truncOrBitCast_Int64_Int16"(%zext2 : $Builtin.Int64) : $Builtin.Int16
+  return %trunc2 : $Builtin.Int16
+}
+
 sil @eliminate_dead_thin_to_thick_function_fun : $@convention(thin) () -> ()
 
 // CHECK-LABEL: sil @eliminate_dead_thin_to_thick_function : $@convention(thin) () -> () {