SILOptimizer: add the StripObjectHeader optimization pass

It sets the `[bare]` attribute for `alloc_ref` and `global_value` instructions if their header (reference count and metatype) is not used throughout the lifetime of the object.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -19,4 +19,5 @@ swift_compiler_sources(Optimizer
   ReleaseDevirtualizer.swift
   SimplificationPasses.swift
   StackPromotion.swift
+  StripObjectHeaders.swift
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StripObjectHeaders.swift

@@ -0,0 +1,73 @@
+//===--- StripObjectHeaders.swift ------------------------------------------==//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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 SIL
+
+/// Sets the `[bare]` attribute for `alloc_ref` and `global_value` instructions
+/// if their header (reference count and metatype) is not used throughout the
+/// lifetime of the object.
+///
+let stripObjectHeadersPass = FunctionPass(name: "strip-object-headers") {
+  (function: Function, context: FunctionPassContext) in
+
+  for inst in function.instructions {
+    switch inst {
+    case let gv as GlobalValueInst:
+      if !gv.isBare && !gv.needObjectHeader(context) {
+        gv.setIsBare(context)
+      }
+    case let ar as AllocRefInst:
+      if !ar.isBare && !ar.needObjectHeader(context) {
+        ar.setIsBare(context)
+      }
+    default:
+      break
+    }
+  }
+}
+
+private extension Value {
+  func needObjectHeader(_ context: FunctionPassContext) -> Bool {
+    var walker = IsBareObjectWalker()
+    return walker.walkDownUses(ofValue: self, path: SmallProjectionPath()) == .abortWalk
+  }
+}
+
+private struct IsBareObjectWalker : ValueDefUseWalker {
+  var walkDownCache = WalkerCache<SmallProjectionPath>()
+
+  mutating func walkDown(value operand: Operand, path: Path) -> WalkResult {
+    switch operand.instruction {
+    case is StructInst, is TupleInst, is EnumInst,
+         is StructExtractInst, is TupleExtractInst, is UncheckedEnumDataInst,
+         is DestructureStructInst, is DestructureTupleInst,
+         is BeginBorrowInst, is MarkDependenceInst,
+         is BranchInst, is CondBranchInst, is SwitchEnumInst,
+         is UpcastInst, is UncheckedRefCastInst,
+         is EndCOWMutationInst:
+      return walkDownDefault(value: operand, path: path)
+    default:
+      return leafUse(value: operand, path: path)
+    }
+  }
+
+  mutating func leafUse(value operand: Operand, path: SmallProjectionPath) -> WalkResult {
+    switch operand.instruction {
+    case is RefElementAddrInst, is RefTailAddrInst,
+         is DeallocRefInst, is DeallocStackRefInst, is SetDeallocatingInst,
+         is DebugValueInst, is FixLifetimeInst:
+      return .continueWalk
+    default:
+      return .abortWalk
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -81,6 +81,7 @@ private func registerSwiftPasses() {
   registerPass(lateOnoneSimplificationPass, { lateOnoneSimplificationPass.run($0) })
   registerPass(cleanupDebugStepsPass, { cleanupDebugStepsPass.run($0) })
   registerPass(namedReturnValueOptimization, { namedReturnValueOptimization.run($0) })
+  registerPass(stripObjectHeadersPass, { stripObjectHeadersPass.run($0) })
 
   // Instruction passes
   registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })

include/swift/SILOptimizer/PassManager/Passes.def

@@ -401,6 +401,8 @@ SWIFT_FUNCTION_PASS(CleanupDebugSteps, "cleanup-debug-steps",
     "Cleanup debug_step instructions for Onone")
 SWIFT_FUNCTION_PASS(NamedReturnValueOptimization, "named-return-value-optimization",
     "Optimize copies to an indirect return value")
+SWIFT_FUNCTION_PASS(StripObjectHeaders, "strip-object-headers",
+    "Sets the bare flag on objects which don't need their headers")
 PASS(SimplifyBBArgs, "simplify-bb-args",
      "SIL Block Argument Simplification")
 PASS(SimplifyCFG, "simplify-cfg",

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -807,6 +807,7 @@ static void addLateLoopOptPassPipeline(SILPassPipelinePlan &P) {
   P.addDCE();
   P.addSILCombine();
   P.addSimplifyCFG();
+  P.addStripObjectHeaders();
 
   // Try to hoist all releases, including epilogue releases. This should be
   // after FSO.

test/SILOptimizer/static_arrays.swift

@@ -98,7 +98,7 @@
 public let globalVariable = [ 100, 101, 102 ]
 
 // CHECK-LABEL: sil [noinline] @$s4test11arrayLookupyS2iF
-// CHECK:   global_value @$s4test11arrayLookupyS2iFTv_
+// CHECK:   global_value [bare] @$s4test11arrayLookupyS2iFTv_
 // CHECK-NOT: retain
 // CHECK-NOT: release
 // CHECK:   } // end sil function '$s4test11arrayLookupyS2iF'

test/SILOptimizer/strip_object_header.sil

@@ -0,0 +1,66 @@
+// RUN: %target-sil-opt  %s -strip-object-headers | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+sil_stage canonical
+
+import Builtin
+import Swift
+import SwiftShims
+
+class B {
+}
+class C : B {
+  @_hasStorage var a: Int
+}
+
+sil_global @g : $C
+
+sil @unknown_func : $@convention(thin) (@guaranteed C) -> ()
+
+// CHECK-LABEL: sil @test_alloc_ref :
+// CHECK:         alloc_ref [bare] [stack] $C
+// CHECK:       } // end sil function 'test_alloc_ref'
+sil @test_alloc_ref : $@convention(thin) () -> () {
+bb0:
+  %0 = alloc_ref [stack] $C
+  debug_value %0 : $C, let, name "x"
+  %1 = upcast %0 : $C to $B
+  %2 = end_cow_mutation %1 : $B
+  %3 = unchecked_ref_cast %2 : $B to $C
+  %4 = ref_element_addr %3 : $C, #C.a
+  %5 = ref_tail_addr %3 : $C, $Int
+  set_deallocating %0 : $C
+  fix_lifetime %0 : $C
+  dealloc_ref %0 : $C
+  dealloc_stack_ref %0 : $C
+  %6 = tuple ()
+  return %6 : $()
+}
+
+// CHECK-LABEL: sil @test_global_value :
+// CHECK:         global_value [bare] @g
+// CHECK:       } // end sil function 'test_global_value'
+sil @test_global_value : $@convention(thin) () -> () {
+bb0:
+  %0 = global_value @g : $C
+  debug_value %0 : $C, let, name "x"
+  %4 = ref_element_addr %0 : $C, #C.a
+  %5 = ref_tail_addr %0 : $C, $Int
+  %6 = tuple ()
+  return %6 : $()
+}
+
+// CHECK-LABEL: sil @test_not_bare :
+// CHECK:         alloc_ref [stack] $C
+// CHECK:       } // end sil function 'test_not_bare'
+sil @test_not_bare : $@convention(thin) () -> () {
+bb0:
+  %0 = alloc_ref [stack] $C
+  %1 = function_ref @unknown_func : $@convention(thin) (@guaranteed C) -> ()
+  %2 = apply %1(%0) : $@convention(thin) (@guaranteed C) -> ()
+  dealloc_stack_ref %0 : $C
+  %6 = tuple ()
+  return %6 : $()
+}
+