SILOptimizer: extract the peephole optimization for Builtin.canBeClass into a separate utility.

Author: eeckstein

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -715,6 +715,10 @@ void endLifetimeAtLeakingBlocks(SILValue value,
 bool tryEliminateOnlyOwnershipUsedForwardingInst(
     SingleValueInstruction *forwardingInst, InstModCallbacks &callbacks);
 
+/// Constant-fold the Builtin.canBeClass if the type is known.
+IntegerLiteralInst *optimizeBuiltinCanBeObjCClass(BuiltinInst *bi,
+                                                  SILBuilder &builder);
+
 } // end namespace swift
 
 #endif

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -345,7 +345,6 @@ class SILCombiner :
 #include "swift/SILOptimizer/PassManager/Passes.def"
 
   /// Instruction visitor helpers.
-  SILInstruction *optimizeBuiltinCanBeObjCClass(BuiltinInst *AI);
 
   // Optimize the "isConcrete" builtin.
   SILInstruction *optimizeBuiltinIsConcrete(BuiltinInst *I);

lib/SILOptimizer/SILCombiner/SILCombinerBuiltinVisitors.cpp

@@ -82,28 +82,6 @@ SILInstruction *SILCombiner::optimizeBuiltinCompareEq(BuiltinInst *BI,
                                       APInt(1, Val));
 }
 
-SILInstruction *SILCombiner::optimizeBuiltinCanBeObjCClass(BuiltinInst *BI) {
-  assert(BI->hasSubstitutions() && "Expected substitutions for canBeClass");
-
-  auto const &Subs = BI->getSubstitutions();
-  assert((Subs.getReplacementTypes().size() == 1) &&
-         "Expected one substitution in call to canBeClass");
-
-  auto Ty = Subs.getReplacementTypes()[0]->getCanonicalType();
-  switch (Ty->canBeClass()) {
-  case TypeTraitResult::IsNot:
-    return Builder.createIntegerLiteral(BI->getLoc(), BI->getType(),
-                                        APInt(8, 0));
-  case TypeTraitResult::Is:
-    return Builder.createIntegerLiteral(BI->getLoc(), BI->getType(),
-                                        APInt(8, 1));
-  case TypeTraitResult::CanBe:
-    return nullptr;
-  }
-
-  llvm_unreachable("Unhandled TypeTraitResult in switch.");
-}
-
 SILInstruction *SILCombiner::optimizeBuiltinIsConcrete(BuiltinInst *BI) {
   if (BI->getOperand(0)->getType().hasArchetype())
     return nullptr;
@@ -680,7 +658,7 @@ SILInstruction *SILCombiner::optimizeStringObject(BuiltinInst *BI) {
 
 SILInstruction *SILCombiner::visitBuiltinInst(BuiltinInst *I) {
   if (I->getBuiltinInfo().ID == BuiltinValueKind::CanBeObjCClass)
-    return optimizeBuiltinCanBeObjCClass(I);
+    return optimizeBuiltinCanBeObjCClass(I, Builder);
   if (I->getBuiltinInfo().ID == BuiltinValueKind::IsConcrete)
     return optimizeBuiltinIsConcrete(I);
   if (I->getBuiltinInfo().ID == BuiltinValueKind::COWBufferForReading)

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -2249,3 +2249,26 @@ void swift::salvageDebugInfo(SILInstruction *I) {
       }
   }
 }
+
+IntegerLiteralInst *swift::optimizeBuiltinCanBeObjCClass(BuiltinInst *bi,
+                                                         SILBuilder &builder) {
+  assert(bi->getBuiltinInfo().ID == BuiltinValueKind::CanBeObjCClass);
+  assert(bi->hasSubstitutions() && "Expected substitutions for canBeClass");
+
+  auto const &subs = bi->getSubstitutions();
+  assert((subs.getReplacementTypes().size() == 1) &&
+         "Expected one substitution in call to canBeClass");
+
+  auto ty = subs.getReplacementTypes()[0]->getCanonicalType();
+  switch (ty->canBeClass()) {
+  case TypeTraitResult::IsNot:
+    return builder.createIntegerLiteral(bi->getLoc(), bi->getType(),
+                                        APInt(8, 0));
+  case TypeTraitResult::Is:
+    return builder.createIntegerLiteral(bi->getLoc(), bi->getType(),
+                                        APInt(8, 1));
+  case TypeTraitResult::CanBe:
+    return nullptr;
+  }
+  llvm_unreachable("Unhandled TypeTraitResult in switch.");
+}