Merge pull request #66990 from eeckstein/bare-objects

SIL: add a `bare` attribute to `global_value` and `alloc_ref`

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/ObjectOutliner.swift

@@ -310,7 +310,7 @@ private func replace(object allocRef: AllocRefInstBase,
 
   // Replace the alloc_ref by global_value + strong_retain instructions.
   let builder = Builder(before: allocRef, context)
-  let globalValue = builder.createGlobalValue(global: global)
+  let globalValue = builder.createGlobalValue(global: global, isBare: false)
   builder.createStrongRetain(operand: globalValue)
 
   endCOW.uses.replaceAll(with: endCOW.instance, context)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StripObjectHeaders.swift

@@ -0,0 +1,75 @@
+//===--- 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() {
+        gv.setIsBare(context)
+      }
+    case let ar as AllocRefInst:
+      if !ar.isBare && !ar.needObjectHeader() {
+        ar.setIsBare(context)
+      }
+    default:
+      break
+    }
+  }
+}
+
+private extension Value {
+  func needObjectHeader() -> 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 {
+    // White-list all instructions which don't use the object header.
+    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 {
+    // White-list all instructions which don't use the object header.
+    case is RefElementAddrInst, is RefTailAddrInst,
+         is DeallocRefInst, is DeallocStackRefInst, is SetDeallocatingInst,
+         is DebugValueInst, is FixLifetimeInst:
+      return .continueWalk
+    default:
+      return .abortWalk
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -430,6 +430,22 @@ extension RefCountingInst {
   }
 }
 
+extension AllocRefInst {
+  func setIsBare(_ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.AllocRefInst_setIsBare()
+    context.notifyInstructionChanged(self)
+  }
+}
+
+extension GlobalValueInst {
+  func setIsBare(_ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.GlobalValueInst_setIsBare()
+    context.notifyInstructionChanged(self)
+  }
+}
+
 extension TermInst {
   func replaceBranchTarget(from fromBlock: BasicBlock, to toBlock: BasicBlock, _ context: some MutatingContext) {
     context.notifyBranchesChanged()

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) })

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -239,8 +239,8 @@ public struct Builder {
     return notifyNew(bridged.createGlobalAddr(global.bridged).getAs(GlobalAddrInst.self))
   }
 
-  public func createGlobalValue(global: GlobalVariable) -> GlobalValueInst {
-    return notifyNew(bridged.createGlobalValue(global.bridged).getAs(GlobalValueInst.self))
+  public func createGlobalValue(global: GlobalVariable, isBare: Bool) -> GlobalValueInst {
+    return notifyNew(bridged.createGlobalValue(global.bridged, isBare).getAs(GlobalValueInst.self))
   }
 
   public func createStruct(type: Type, elements: [Value]) -> StructInst {

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -523,7 +523,9 @@ final public class PreviousDynamicFunctionRefInst : FunctionRefBaseInst {
 
 final public class GlobalAddrInst : GlobalAccessInst {}
 
-final public class GlobalValueInst : GlobalAccessInst {}
+final public class GlobalValueInst : GlobalAccessInst {
+  public var isBare: Bool { bridged.GlobalValueInst_isBare() }
+}
 
 final public class AllocGlobalInst : Instruction {
   public var global: GlobalVariable {
@@ -837,6 +839,7 @@ public class AllocRefInstBase : SingleValueInstruction, Allocation {
 }
 
 final public class AllocRefInst : AllocRefInstBase {
+  public var isBare: Bool { bridged.AllocRefInst_isBare() }
 }
 
 final public class AllocRefDynamicInst : AllocRefInstBase {

docs/SIL.rst

@@ -3816,6 +3816,7 @@ alloc_ref
 ::
 
   sil-instruction ::= 'alloc_ref'
+                        ('[' 'bare' ']')?
                         ('[' 'objc' ']')?
                         ('[' 'stack' ']')?
                         ('[' 'tail_elems' sil-type '*' sil-operand ']')*
@@ -3842,6 +3843,11 @@ possible. The final decision on stack allocation is done during llvm IR
 generation. This is because the decision also depends on the object size,
 which is not necessarily known at SIL level.
 
+The ``bare`` attribute indicates that the object header is not used throughout
+the lifetime of the object. This means, no reference counting operations are
+performed on the object and its metadata is not used. The header of bare
+objects doesn't need to be initialized.
+
 The optional ``tail_elems`` attributes specifies the amount of space to be
 reserved for tail-allocated arrays of given element types and element counts.
 If there are more than one ``tail_elems`` attributes then the tail arrays are
@@ -5484,7 +5490,7 @@ global_value
 `````````````
 ::
 
-  sil-instruction ::= 'global_value' sil-global-name ':' sil-type
+  sil-instruction ::= 'global_value' ('[' 'bare' ']')? sil-global-name ':' sil-type
 
   %1 = global_value @v : $T
 
@@ -5493,6 +5499,11 @@ by ``alloc_global``. It is undefined behavior to perform this operation on a
 global variable which has not been initialized, except the global variable
 has a static initializer.
 
+The ``bare`` attribute indicates that the object header is not used throughout
+the lifetime of the value. This means, no reference counting operations are
+performed on the object and its metadata is not used. The header of bare
+objects doesn't need to be initialized.
+
 integer_literal
 ```````````````
 ::

include/swift/SIL/SILBridging.h

@@ -760,6 +760,14 @@ struct BridgedInstruction {
     getAs<swift::AllocRefInstBase>()->setStackAllocatable();
   }
 
+  bool AllocRefInst_isBare() const {
+    return getAs<swift::AllocRefInst>()->isBare();
+  }
+
+  void AllocRefInst_setIsBare() const {
+    getAs<swift::AllocRefInst>()->setBare(true);
+  }
+
   inline void TermInst_replaceBranchTarget(BridgedBasicBlock from, BridgedBasicBlock to) const;
 
   SwiftInt KeyPathInst_getNumComponents() const {
@@ -786,6 +794,14 @@ struct BridgedInstruction {
       }, [](swift::SILDeclRef) {});
   }
 
+  bool GlobalValueInst_isBare() const {
+    return getAs<swift::GlobalValueInst>()->isBare();
+  }
+
+  void GlobalValueInst_setIsBare() const {
+    getAs<swift::GlobalValueInst>()->setBare(true);
+  }
+
   SWIFT_IMPORT_UNSAFE
   inline BridgedBasicBlock CheckedCastBranch_getSuccessBlock() const;
 
@@ -1242,8 +1258,8 @@ struct BridgedBuilder{
   }
 
   SWIFT_IMPORT_UNSAFE
-  BridgedInstruction createGlobalValue(BridgedGlobalVar global) const {
-    return {builder().createGlobalValue(regularLoc(), global.getGlobal())};
+  BridgedInstruction createGlobalValue(BridgedGlobalVar global, bool isBare) const {
+    return {builder().createGlobalValue(regularLoc(), global.getGlobal(), isBare)};
   }
 
   SWIFT_IMPORT_UNSAFE

include/swift/SIL/SILBuilder.h

@@ -446,14 +446,14 @@ class SILBuilder {
   }
 
   AllocRefInst *createAllocRef(SILLocation Loc, SILType ObjectType,
-                               bool objc, bool canAllocOnStack,
+                               bool objc, bool canAllocOnStack, bool isBare,
                                ArrayRef<SILType> ElementTypes,
                                ArrayRef<SILValue> ElementCountOperands) {
     // AllocRefInsts expand to function calls and can therefore not be
     // counted towards the function prologue.
     assert(!Loc.isInPrologue());
     return insert(AllocRefInst::create(getSILDebugLocation(Loc), getFunction(),
-                                       ObjectType, objc, canAllocOnStack,
+                                       ObjectType, objc, canAllocOnStack, isBare,
                                        ElementTypes, ElementCountOperands));
   }
 
@@ -682,9 +682,9 @@ class SILBuilder {
     return insert(new (F->getModule())
                   GlobalAddrInst(getSILDebugLocation(Loc), Ty));
   }
-  GlobalValueInst *createGlobalValue(SILLocation Loc, SILGlobalVariable *g) {
+  GlobalValueInst *createGlobalValue(SILLocation Loc, SILGlobalVariable *g, bool isBare) {
     return insert(new (getModule()) GlobalValueInst(getSILDebugLocation(Loc), g,
-                                                    getTypeExpansionContext()));
+                                                    getTypeExpansionContext(), isBare));
   }
   BaseAddrForOffsetInst *createBaseAddrForOffset(SILLocation Loc, SILType Ty) {
     return insert(new (F->getModule())