DeinitDevirtualizer: de-virtualize deinits of builtin "destroyArray"

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DeinitDevirtualizer.swift

@@ -27,6 +27,8 @@ let deinitDevirtualizer = FunctionPass(name: "deinit-devirtualizer") {
       _ = devirtualizeDeinits(of: destroyValue, context)
     case let destroyAddr as DestroyAddrInst:
       _ = devirtualizeDeinits(of: destroyAddr, context)
+    case let builtin as BuiltinInst:
+      _ = devirtualizeDeinits(of: builtin, context)
     default:
       break
     }

test/SILOptimizer/devirt_deinits.sil

@@ -304,6 +304,34 @@ bb0(%0 : $*S1):
   return %r : $()
 }
 
+// CHECK-LABEL: sil [ossa] @test_destroyArray :
+// CHECK:         [[ZERO:%.*]] = integer_literal $Builtin.Word, 0
+// CHECK:         [[ONE:%.*]] = integer_literal $Builtin.Word, 1
+// CHECK:         [[FALSE:%.*]] = integer_literal $Builtin.Int1, 0
+// CHECK:         [[PTA:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*S1
+// CHECK:         br bb1([[ZERO]] : $Builtin.Word)
+// CHECK:       bb1([[IV:%.*]] : $Builtin.Word):
+// CHECK:         [[CMP:%.*]] = builtin "cmp_slt_Word"([[IV]] : $Builtin.Word, %1 : $Builtin.Word)
+// CHECK:         cond_br [[CMP]], bb2, bb3
+// CHECK:       bb2:
+// CHECK:         [[ADDR:%.*]] = index_addr [[PTA]] :  $*S1, [[IV]]
+// CHECK:         [[DEINIT:%.*]] = function_ref @s1_deinit :
+// CHECK:         [[ELEMENT:%.*]] = load [take] [[ADDR]]
+// CHECK:         apply [[DEINIT]]([[ELEMENT]])
+// CHECK:         [[ADD:%.*]] = builtin "sadd_with_overflow_Word"([[IV]] : $Builtin.Word, [[ONE]] : $Builtin.Word, [[FALSE]] : $Builtin.Int1)
+// CHECK:         [[INCR:%.*]] = tuple_extract [[ADD]] : $(Builtin.Word, Builtin.Int1), 0
+// CHECK:         br bb1([[INCR]] : $Builtin.Word)
+// CHECKL       bb3:
+// CHECK:       } // end sil function 'test_destroyArray'
+sil [ossa] @test_destroyArray : $@convention(thin) (Builtin.RawPointer, Builtin.Word) -> () {
+bb0(%0 : $Builtin.RawPointer, %1 : $Builtin.Word):
+  %2 = metatype $@thin S1.Type                    // user: %10
+  %3 = builtin "destroyArray"<S1>(%2, %0, %1) : $()
+  %r = tuple ()
+  return %r
+}
+
+
 sil @s1_deinit : $@convention(method) (@owned S1) -> ()
 sil @s2_deinit : $@convention(method) (@owned S2) -> ()
 sil @s3_deinit : $@convention(method) <T> (@in S3<T>) -> ()

test/SILOptimizer/devirt_deinits.swift

@@ -51,6 +51,16 @@ struct S3: ~Copyable {
   }
 }
 
+struct S4: ~Copyable {
+  var x: Int
+
+  @inline(never)
+  deinit {
+    print(x)
+  }
+}
+
+
 enum EnumWithDeinit: ~Copyable {
   case A(Int)
   case B
@@ -136,6 +146,18 @@ func testNestedDeinit(_ s: consuming S3) {
   log("### testNestedDeinit")
 }
 
+// CHECK-LABEL: sil hidden [noinline] @$s4test0A12DestroyArrayyySryAA2S4VGF :
+// CHECK-NOT:     "destroyArray"
+// CHECK:         [[D:%.*]] = function_ref @$s4test2S4VfD :
+// CHECK:         apply [[D]]
+// CHECK-NOT:     "destroyArray"
+// CHECK:       } // end sil function '$s4test0A12DestroyArrayyySryAA2S4VGF'
+@inline(never)
+func testDestroyArray(_ p: UnsafeMutableBufferPointer<S4>) {
+  p.deinitialize()
+}
+
+
 @main
 struct Main {
   static func main() {
@@ -182,6 +204,21 @@ struct Main {
     // CHECK-OUTPUT-NEXT:  ---
     testNestedDeinit(S3())
     log("---")
+
+    let b = UnsafeMutableBufferPointer<S4>.allocate(capacity: 3)
+    for i in 0..<3 {
+      b.initializeElement(at: i, to: S4(x: i))
+    }
+
+    // CHECK-OUTPUT-LABEL: ### testDestroyArray
+    // CHECK-OUTPUT-NEXT:  0
+    // CHECK-OUTPUT-NEXT:  1
+    // CHECK-OUTPUT-NEXT:  2
+    // CHECK-OUTPUT-NEXT:  ---
+    log("### testDestroyArray")
+    testDestroyArray(b)
+    b.deallocate()
+    log("---")
   }
 }