Optimizer: add constant folding of classify_bridge_object

Constant fold `classify_bridge_object` to `(false, false)` if the operand is known to be a swift class.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -14,6 +14,7 @@ swift_compiler_sources(Optimizer
   SimplifyBranch.swift
   SimplifyBuiltin.swift
   SimplifyCheckedCast.swift
+  SimplifyClassifyBridgeObject.swift
   SimplifyCondBranch.swift
   SimplifyCondFail.swift
   SimplifyConvertEscapeToNoEscape.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyClassifyBridgeObject.swift

@@ -0,0 +1,50 @@
+//===--- SimplifyClassifyBridgeObject.swift -------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import AST
+import SIL
+
+extension ClassifyBridgeObjectInst : OnoneSimplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    // Constant fold `classify_bridge_object` to `(false, false)` if the operand is known
+    // to be a swift class.
+    var walker = CheckForSwiftClasses();
+    if walker.walkUp(value: operand.value, path: UnusedWalkingPath()) == .abortWalk {
+      return
+    }
+
+    let builder = Builder(before: self, context)
+    let falseLiteral = builder.createIntegerLiteral(0, type: context.getBuiltinIntegerType(bitWidth: 1))
+    let tp = builder.createTuple(type: self.type, elements: [falseLiteral, falseLiteral])
+    uses.replaceAll(with: tp, context)
+    context.erase(instruction: self)
+  }
+}
+
+private struct CheckForSwiftClasses: ValueUseDefWalker {
+  mutating func walkUp(value: Value, path: UnusedWalkingPath) -> WalkResult {
+    if let nominal = value.type.nominal,
+       let classDecl = nominal as? ClassDecl,
+       !classDecl.isObjC
+    {
+      // Stop this use-def walk if the value is known to be a swift class.
+      return .continueWalk
+    }
+    return walkUpDefault(value: value, path: path)
+  }
+
+  mutating func rootDef(value: Value, path: UnusedWalkingPath) -> WalkResult {
+    return .abortWalk
+  }
+
+  var walkUpCache = WalkerCache<UnusedWalkingPath>()
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -111,6 +111,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })
   registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })
   registerForSILCombine(TypeValueInst.self, { run(TypeValueInst.self, $0) })
+  registerForSILCombine(ClassifyBridgeObjectInst.self, { run(ClassifyBridgeObjectInst.self, $0) })
 
   // Test passes
   registerPass(aliasInfoDumper, { aliasInfoDumper.run($0) })

include/swift/SILOptimizer/PassManager/Passes.def

@@ -517,6 +517,7 @@ PASS(PruneVTables, "prune-vtables",
 PASS_RANGE(AllPasses, AliasInfoDumper, PruneVTables)
 
 SWIFT_SILCOMBINE_PASS(BeginCOWMutationInst)
+SWIFT_SILCOMBINE_PASS(ClassifyBridgeObjectInst)
 SWIFT_SILCOMBINE_PASS(GlobalValueInst)
 SWIFT_SILCOMBINE_PASS(StrongRetainInst)
 SWIFT_SILCOMBINE_PASS(StrongReleaseInst)

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -292,7 +292,6 @@ class SILCombiner :
   SILInstruction *visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI);
 
   SILInstruction *visitMarkDependenceInst(MarkDependenceInst *MDI);
-  SILInstruction *visitClassifyBridgeObjectInst(ClassifyBridgeObjectInst *CBOI);
   SILInstruction *visitConvertFunctionInst(ConvertFunctionInst *CFI);
   SILInstruction *
   visitConvertEscapeToNoEscapeInst(ConvertEscapeToNoEscapeInst *Cvt);

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -2006,24 +2006,6 @@ SILInstruction *SILCombiner::visitMarkDependenceInst(MarkDependenceInst *mdi) {
   return nullptr;
 }
 
-SILInstruction *
-SILCombiner::visitClassifyBridgeObjectInst(ClassifyBridgeObjectInst *cboi) {
-  auto *urc = dyn_cast<UncheckedRefCastInst>(cboi->getOperand());
-  if (!urc)
-    return nullptr;
-
-  auto type = urc->getOperand()->getType().getASTType();
-  if (ClassDecl *cd = type->getClassOrBoundGenericClass()) {
-    if (!cd->isObjC()) {
-      auto int1Ty = SILType::getBuiltinIntegerType(1, Builder.getASTContext());
-      SILValue zero = Builder.createIntegerLiteral(cboi->getLoc(), int1Ty, 0);
-      return Builder.createTuple(cboi->getLoc(), {zero, zero});
-    }
-  }
-
-  return nullptr;
-}
-
 /// Returns true if reference counting and debug_value users of a global_value
 /// can be deleted.
 static bool checkGlobalValueUsers(SILValue val,

test/SILOptimizer/simplify_classify_bridge_object.sil

@@ -0,0 +1,35 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -onone-simplification -simplify-instruction=classify_bridge_object | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+import Swift
+import Builtin
+
+struct MyArray {
+  let o: Builtin.BridgeObject
+}
+
+// CHECK-LABEL: sil @test_swift_class :
+// CHECK:         %1 = integer_literal $Builtin.Int1, 0
+// CHECK:         %2 = tuple (%1 : $Builtin.Int1, %1 : $Builtin.Int1)
+// CHECK:         return %2
+// CHECK:       } // end sil function 'test_swift_class'
+sil @test_swift_class : $@convention(thin) (@guaranteed _ContiguousArrayStorage<Int>) -> (Builtin.Int1, Builtin.Int1) {
+bb0(%0 : $_ContiguousArrayStorage<Int>):
+  %1 = unchecked_ref_cast %0 : $_ContiguousArrayStorage<Int> to $Builtin.BridgeObject
+  %2 = classify_bridge_object %1 : $Builtin.BridgeObject
+  return %2 : $(Builtin.Int1, Builtin.Int1)
+}
+
+// CHECK-LABEL: sil @test_unknown_class :
+// CHECK:         %1 = struct_extract %0
+// CHECK:         %2 = classify_bridge_object %1
+// CHECK:         return %2
+// CHECK:       } // end sil function 'test_unknown_class'
+sil @test_unknown_class : $@convention(thin) (@guaranteed MyArray) -> (Builtin.Int1, Builtin.Int1) {
+bb0(%0 : $MyArray):
+  %1 = struct_extract %0 : $MyArray, #MyArray.o
+  %2 = classify_bridge_object %1 : $Builtin.BridgeObject
+  return %2 : $(Builtin.Int1, Builtin.Int1)
+}
+