IRGen: don't initialize the object headers of bare objects

eeckstein · eeckstein · commit e77e2bcff7fc · 2023-06-29T06:57:05.000+02:00
For `alloc_ref [bare] [stack]` and `global_value [bare]` omit the object header initialization.
The `bare` flag means that the object header is not used.

This was already done with a peephole optimization inside IRGen for `global_value`. But now rely on the SIL `bare` flag.
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StripObjectHeaders.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StripObjectHeaders.swift
@@ -22,11 +22,11 @@ let stripObjectHeadersPass = FunctionPass(name: "strip-object-headers") {
   for inst in function.instructions {
     switch inst {
     case let gv as GlobalValueInst:
-      if !gv.isBare && !gv.needObjectHeader(context) {
+      if !gv.isBare && !gv.needObjectHeader() {
         gv.setIsBare(context)
       }
     case let ar as AllocRefInst:
-      if !ar.isBare && !ar.needObjectHeader(context) {
+      if !ar.isBare && !ar.needObjectHeader() {
         ar.setIsBare(context)
       }
     default:
@@ -36,7 +36,7 @@ let stripObjectHeadersPass = FunctionPass(name: "strip-object-headers") {
 }
 
 private extension Value {
-  func needObjectHeader(_ context: FunctionPassContext) -> Bool {
+  func needObjectHeader() -> Bool {
     var walker = IsBareObjectWalker()
     return walker.walkDownUses(ofValue: self, path: SmallProjectionPath()) == .abortWalk
   }
@@ -47,6 +47,7 @@ private struct IsBareObjectWalker : ValueDefUseWalker {
 
   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,
@@ -62,6 +63,7 @@ private struct IsBareObjectWalker : ValueDefUseWalker {
 
   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:
diff --git a/lib/IRGen/GenClass.cpp b/lib/IRGen/GenClass.cpp
@@ -857,7 +857,8 @@ irgen::appendSizeForTailAllocatedArrays(IRGenFunction &IGF,
 
 /// Emit an allocation of a class.
 llvm::Value *irgen::emitClassAllocation(IRGenFunction &IGF, SILType selfType,
-                                        bool objc, int &StackAllocSize,
+                                        bool objc, bool isBare,
+                                        int &StackAllocSize,
                                         TailArraysRef TailArrays) {
   auto &classTI = IGF.getTypeInfo(selfType).as<ClassTypeInfo>();
   auto classType = selfType.getASTType();
@@ -874,20 +875,28 @@ llvm::Value *irgen::emitClassAllocation(IRGenFunction &IGF, SILType selfType,
     return emitObjCAllocObjectCall(IGF, metadata, selfType);
   }
 
-  llvm::Value *metadata =
-    emitClassHeapMetadataRef(IGF, classType, MetadataValueType::TypeMetadata,
-                             MetadataState::Complete);
-
   auto &classLayout = classTI.getClassLayout(IGF.IGM, selfType,
                                              /*forBackwardDeployment=*/false);
 
   llvm::Type *destType = classLayout.getType()->getPointerTo();
   llvm::Value *val = nullptr;
   if (llvm::Value *Promoted = stackPromote(IGF, classLayout, StackAllocSize,
                                            TailArrays)) {
-    val = IGF.Builder.CreateBitCast(Promoted, IGF.IGM.RefCountedPtrTy);
-    val = IGF.emitInitStackObjectCall(metadata, val, "reference.new");
+    if (isBare) {
+      val = Promoted;
+    } else {
+      llvm::Value *metadata =
+        emitClassHeapMetadataRef(IGF, classType, MetadataValueType::TypeMetadata,
+                                 MetadataState::Complete);
+
+      val = IGF.Builder.CreateBitCast(Promoted, IGF.IGM.RefCountedPtrTy);
+      val = IGF.emitInitStackObjectCall(metadata, val, "reference.new");
+    }
   } else {
+    llvm::Value *metadata =
+      emitClassHeapMetadataRef(IGF, classType, MetadataValueType::TypeMetadata,
+                               MetadataState::Complete);
+
     llvm::Value *size, *alignMask;
     if (classLayout.isFixedSize()) {
       size = IGF.IGM.getSize(classLayout.getSize());
diff --git a/lib/IRGen/GenClass.h b/lib/IRGen/GenClass.h
@@ -166,7 +166,7 @@ namespace irgen {
   /// The returned \p StackAllocSize value is the actual size if the object is
   /// allocated on the stack or -1, if the object is allocated on the heap.
   llvm::Value *emitClassAllocation(IRGenFunction &IGF, SILType selfType,
-                  bool objc, int &StackAllocSize, TailArraysRef TailArrays);
+                  bool objc, bool isBare, int &StackAllocSize, TailArraysRef TailArrays);
 
   /// Emit an allocation of a class using a metadata value.
   llvm::Value *emitClassAllocationDynamic(IRGenFunction &IGF,
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -2987,23 +2987,6 @@ void IRGenSILFunction::visitGlobalAddrInst(GlobalAddrInst *i) {
   setLoweredAddress(i, addr);
 }
 
-/// Returns true if \p val has no other uses than ref_element_addr or
-/// ref_tail_addr.
-static bool hasOnlyProjections(SILValue val) {
-  for (Operand *use : val->getUses()) {
-    SILInstruction *user = use->getUser();
-    if (auto *upCast = dyn_cast<UpcastInst>(user)) {
-      if (!hasOnlyProjections(upCast))
-        return false;
-      continue;
-    }
-    if (isa<RefElementAddrInst>(user) || isa<RefTailAddrInst>(user))
-      continue;
-    return false;
-  }
-  return true;
-}
-
 void IRGenSILFunction::visitGlobalValueInst(GlobalValueInst *i) {
   SILGlobalVariable *var = i->getReferencedGlobal();
   assert(var->isInitializedObject() &&
@@ -3017,7 +3000,7 @@ void IRGenSILFunction::visitGlobalValueInst(GlobalValueInst *i) {
                                                 NotForDefinition).getAddress();
   // We don't need to initialize the global object if it's never used for
   // something which can access the object header.
-  if (!hasOnlyProjections(i) && !IGM.canMakeStaticObjectsReadOnly()) {
+  if (!i->isBare() && !IGM.canMakeStaticObjectsReadOnly()) {
     auto ClassType = loweredTy.getASTType();
     llvm::Value *Metadata =
       emitClassHeapMetadataRef(*this, ClassType, MetadataValueType::TypeMetadata,
@@ -4805,6 +4788,9 @@ void IRGenSILFunction::visitAutoreleaseValueInst(swift::AutoreleaseValueInst *i)
 void IRGenSILFunction::visitSetDeallocatingInst(SetDeallocatingInst *i) {
   auto *ARI = dyn_cast<AllocRefInst>(i->getOperand());
   if (ARI && StackAllocs.count(ARI)) {
+    if (ARI->isBare())
+      return;
+
     // A small peep-hole optimization: If the operand is allocated on stack and
     // there is no "significant" code between the set_deallocating and the final
     // dealloc_ref, the set_deallocating is not required.
@@ -5712,7 +5698,7 @@ void IRGenSILFunction::visitAllocRefInst(swift::AllocRefInst *i) {
   SmallVector<std::pair<SILType, llvm::Value *>, 4> TailArrays;
   buildTailArrays(*this, TailArrays, i);
 
-  llvm::Value *alloced = emitClassAllocation(*this, i->getType(), i->isObjC(),
+  llvm::Value *alloced = emitClassAllocation(*this, i->getType(), i->isObjC(), i->isBare(),
                                              StackAllocSize, TailArrays);
   if (StackAllocSize >= 0) {
     // Remember that this alloc_ref allocates the object on the stack.
diff --git a/test/IRGen/class_stack_alloc.sil b/test/IRGen/class_stack_alloc.sil
@@ -105,6 +105,20 @@ bb0:
   return %r : $()
 }
 
+// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @bare_alloc_ref
+// CHECK:         %reference.raw = alloca %[[C:[a-zA-Z0-9_]+]], align 8
+// CHECK-NEXT:    [[O:%[0-9]+]] = bitcast %[[C]]* %reference.raw to i8*
+// CHECK-NEXT:    call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[O]])
+// CHECK-NEXT:    ret void
+sil @bare_alloc_ref : $@convention(thin) () -> () {
+bb0:
+  %o1 = alloc_ref [bare] [stack] $TestClass
+  set_deallocating %o1 : $TestClass
+  dealloc_stack_ref %o1 : $TestClass
+  %r = tuple()
+  return %r : $()
+}
+
 // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @promoted_with_inlined_devirtualized_release
 // CHECK: %reference.raw = alloca %[[C:[a-zA-Z0-9_]+]], align 8
 // CHECK-NEXT: [[MR:%[0-9]+]] = call swiftcc %swift.metadata_response @"$s17class_stack_alloc9TestClassCMa"([[INT]] 0)
diff --git a/test/IRGen/static_initializer.sil b/test/IRGen/static_initializer.sil
@@ -185,6 +185,17 @@ bb0:
   return %1 : $TestArray
 }
 
+// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc i32 @bare_static_array() {{.*}} {
+sil @bare_static_array : $@convention(thin) () -> Int32 {
+bb0:
+  // CHECK: %0 = load i32, {{.*}}@static_array
+  // CHECK: ret i32 %0
+  %0 = global_value [bare] @static_array : $TestArrayStorage
+  %1 = ref_element_addr %0 : $TestArrayStorage, #TestArrayStorage.count
+  %2 = load %1 : $*Int32
+  return %2 : $Int32
+}
+
 // CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc %T18static_initializer16TestArrayStorageC* @phi_nodes(i1 %0, %T18static_initializer16TestArrayStorageC* %1)
 // CHECK: [[T0:%.*]] = call %swift.refcounted* @swift_initStaticObject
 // CHECK: [[T1:%.*]] = bitcast %swift.refcounted* [[T0]] to %T18static_initializer16TestArrayStorageC*
