SIL: add a bare attribute to alloc_ref

eeckstein · eeckstein · commit b08710d91143 · 2023-06-29T06:57:05.000+02:00
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.
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift
@@ -430,6 +430,14 @@ extension RefCountingInst {
   }
 }
 
+extension AllocRefInst {
+  func setIsBare(_ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.AllocRefInst_setIsBare()
+    context.notifyInstructionChanged(self)
+  }
+}
+
 extension TermInst {
   func replaceBranchTarget(from fromBlock: BasicBlock, to toBlock: BasicBlock, _ context: some MutatingContext) {
     context.notifyBranchesChanged()
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift
@@ -837,6 +837,7 @@ public class AllocRefInstBase : SingleValueInstruction, Allocation {
 }
 
 final public class AllocRefInst : AllocRefInstBase {
+  public var isBare: Bool { bridged.AllocRefInst_isBare() }
 }
 
 final public class AllocRefDynamicInst : AllocRefInstBase {
diff --git a/docs/SIL.rst b/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
diff --git a/include/swift/SIL/SILBridging.h b/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 {
diff --git a/include/swift/SIL/SILBuilder.h b/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));
   }
 
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -922,7 +922,7 @@ SILCloner<ImplClass>::visitAllocRefInst(AllocRefInst *Inst) {
   }
   auto *NewInst = getBuilder().createAllocRef(getOpLocation(Inst->getLoc()),
                                       getOpType(Inst->getType()),
-                                      Inst->isObjC(), Inst->canAllocOnStack(),
+                                      Inst->isObjC(), Inst->canAllocOnStack(), Inst->isBare(),
                                       ElemTypes, CountArgs);
   recordClonedInstruction(Inst, NewInst);
 }
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -2206,14 +2206,22 @@ class AllocRefInstBase : public AllocationInst {
   AllocRefInstBase(SILInstructionKind Kind,
                    SILDebugLocation DebugLoc,
                    SILType ObjectType,
-                   bool objc, bool canBeOnStack,
+                   bool objc, bool canBeOnStack, bool isBare,
                    ArrayRef<SILType> ElementTypes);
 
   SILType *getTypeStorage();
   const SILType *getTypeStorage() const {
     return const_cast<AllocRefInstBase*>(this)->getTypeStorage();
   }
 
+  bool isBare() const {
+    return sharedUInt8().AllocRefInstBase.isBare;
+  }
+
+  void setBare(bool isBare = true) {
+    sharedUInt8().AllocRefInstBase.isBare = isBare;
+  }
+
 public:
   unsigned getNumTailTypes() const {
     return sharedUInt8().AllocRefInstBase.numTailTypes;
@@ -2285,23 +2293,31 @@ class AllocRefInst final
 
   AllocRefInst(SILDebugLocation DebugLoc, SILFunction &F,
                SILType ObjectType,
-               bool objc, bool canBeOnStack,
+               bool objc, bool canBeOnStack, bool isBare,
                ArrayRef<SILType> ElementTypes,
                ArrayRef<SILValue> AllOperands)
       : InstructionBaseWithTrailingOperands(AllOperands, DebugLoc, ObjectType,
-                        objc, canBeOnStack, ElementTypes) {
+                        objc, canBeOnStack, isBare, ElementTypes) {
     assert(AllOperands.size() >= ElementTypes.size());
     std::uninitialized_copy(ElementTypes.begin(), ElementTypes.end(),
                             getTrailingObjects<SILType>());
   }
 
   static AllocRefInst *create(SILDebugLocation DebugLoc, SILFunction &F,
                               SILType ObjectType,
-                              bool objc, bool canBeOnStack,
+                              bool objc, bool canBeOnStack, bool isBare,
                               ArrayRef<SILType> ElementTypes,
                               ArrayRef<SILValue> ElementCountOperands);
 
 public:
+  bool isBare() const {
+    return AllocRefInstBase::isBare();
+  }
+
+  void setBare(bool isBare = true) {
+    AllocRefInstBase::setBare(isBare);
+  }
+
   ArrayRef<Operand> getTypeDependentOperands() const {
     return getAllOperands().slice(getNumTailTypes());
   }
@@ -2332,7 +2348,7 @@ class AllocRefDynamicInst final
                       ArrayRef<SILType> ElementTypes,
                       ArrayRef<SILValue> AllOperands)
       : InstructionBaseWithTrailingOperands(AllOperands, DebugLoc, ty, objc,
-                                            canBeOnStack, ElementTypes) {
+                                            canBeOnStack, /*isBare=*/ false, ElementTypes) {
     assert(AllOperands.size() >= ElementTypes.size() + 1);
     std::uninitialized_copy(ElementTypes.begin(), ElementTypes.end(),
                             getTrailingObjects<SILType>());
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -228,6 +228,7 @@ class alignas(8) SILNode :
     SHARED_FIELD(AllocRefInstBase, uint8_t
       objC : 1,
       onStack : 1,
+      isBare : 1,   // Only used in AllocRefInst
       numTailTypes: NumAllocRefTailTypesBits);
 
     SHARED_FIELD(BeginBorrowInst, uint8_t
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -317,11 +317,12 @@ AllocPackInst *AllocPackInst::create(SILDebugLocation loc,
 AllocRefInstBase::AllocRefInstBase(SILInstructionKind Kind,
                                    SILDebugLocation Loc,
                                    SILType ObjectType,
-                                   bool objc, bool canBeOnStack,
+                                   bool objc, bool canBeOnStack, bool isBare,
                                    ArrayRef<SILType> ElementTypes)
     : AllocationInst(Kind, Loc, ObjectType) {
   sharedUInt8().AllocRefInstBase.objC = objc;
   sharedUInt8().AllocRefInstBase.onStack = canBeOnStack;
+  sharedUInt8().AllocRefInstBase.isBare = isBare;
   sharedUInt8().AllocRefInstBase.numTailTypes = ElementTypes.size();
   assert(sharedUInt8().AllocRefInstBase.numTailTypes ==
          ElementTypes.size() && "Truncation");
@@ -330,7 +331,7 @@ AllocRefInstBase::AllocRefInstBase(SILInstructionKind Kind,
 
 AllocRefInst *AllocRefInst::create(SILDebugLocation Loc, SILFunction &F,
                                    SILType ObjectType,
-                                   bool objc, bool canBeOnStack,
+                                   bool objc, bool canBeOnStack, bool isBare,
                                    ArrayRef<SILType> ElementTypes,
                                    ArrayRef<SILValue> ElementCountOperands) {
   assert(ElementTypes.size() == ElementCountOperands.size());
@@ -341,7 +342,7 @@ AllocRefInst *AllocRefInst::create(SILDebugLocation Loc, SILFunction &F,
   auto Size = totalSizeToAlloc<swift::Operand, SILType>(AllOperands.size(),
                                                         ElementTypes.size());
   auto Buffer = F.getModule().allocateInst(Size, alignof(AllocRefInst));
-  return ::new (Buffer) AllocRefInst(Loc, F, ObjectType, objc, canBeOnStack,
+  return ::new (Buffer) AllocRefInst(Loc, F, ObjectType, objc, canBeOnStack, isBare,
                                      ElementTypes, AllOperands);
 }
 
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1452,6 +1452,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   }
 
   void visitAllocRefInst(AllocRefInst *ARI) {
+    if (ARI->isBare())
+      *this << "[bare] ";
     printAllocRefInstBase(ARI);
     *this << ARI->getType();
   }
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -5031,6 +5031,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   case SILInstructionKind::AllocRefDynamicInst: {
     bool IsObjC = false;
     bool OnStack = false;
+    bool isBare = false;
     SmallVector<SILType, 2> ElementTypes;
     SmallVector<SILValue, 2> ElementCounts;
     while (P.consumeIf(tok::l_square)) {
@@ -5041,6 +5042,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         IsObjC = true;
       } else if (Optional == "stack") {
         OnStack = true;
+      } else if (Optional == "bare" && Opcode == SILInstructionKind::AllocRefInst) {
+        isBare = true;
       } else if (Optional == "tail_elems") {
         SILType ElemTy;
         if (parseSILType(ElemTy) || !P.Tok.isAnyOperator() ||
@@ -5082,7 +5085,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
                                           OnStack,
                                           ElementTypes, ElementCounts);
     } else {
-      ResultVal = B.createAllocRef(InstLoc, ObjectType, IsObjC, OnStack,
+      ResultVal = B.createAllocRef(InstLoc, ObjectType, IsObjC, OnStack, isBare,
                                    ElementTypes, ElementCounts);
     }
     break;
diff --git a/lib/SILGen/SILGenBuilder.cpp b/lib/SILGen/SILGenBuilder.cpp
@@ -239,7 +239,7 @@ ManagedValue SILGenBuilder::createPhi(SILType type,
 }
 
 ManagedValue SILGenBuilder::createAllocRef(
-    SILLocation loc, SILType refType, bool objc, bool canAllocOnStack,
+    SILLocation loc, SILType refType, bool objc,
     ArrayRef<SILType> inputElementTypes,
     ArrayRef<ManagedValue> inputElementCountOperands) {
   llvm::SmallVector<SILType, 8> elementTypes(inputElementTypes.begin(),
@@ -249,7 +249,7 @@ ManagedValue SILGenBuilder::createAllocRef(
                   std::back_inserter(elementCountOperands),
                   [](ManagedValue mv) -> SILValue { return mv.getValue(); });
 
-  AllocRefInst *i = createAllocRef(loc, refType, objc, canAllocOnStack,
+  AllocRefInst *i = createAllocRef(loc, refType, objc, false, false,
                                    elementTypes, elementCountOperands);
   return SGF.emitManagedRValueWithCleanup(i);
 }
diff --git a/lib/SILGen/SILGenBuilder.h b/lib/SILGen/SILGenBuilder.h
@@ -177,7 +177,6 @@ class SILGenBuilder : public SILBuilder {
 
   using SILBuilder::createAllocRef;
   ManagedValue createAllocRef(SILLocation loc, SILType refType, bool objc,
-                              bool canAllocOnStack,
                               ArrayRef<SILType> elementTypes,
                               ArrayRef<ManagedValue> elementCountOperands);
   using SILBuilder::createAllocRefDynamic;
diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
@@ -1080,7 +1080,7 @@ static ManagedValue emitBuiltinAllocWithTailElems(SILGenFunction &SGF,
     assert(InstanceType == RefType.getASTType() &&
            "substituted type does not match operand metatype");
     (void) InstanceType;
-    return SGF.B.createAllocRef(loc, RefType, false, false,
+    return SGF.B.createAllocRef(loc, RefType, false,
                                 ElemTypes, Counts);
   } else {
     return SGF.B.createAllocRefDynamic(loc, Metatype, RefType, false,
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -957,7 +957,7 @@ void SILGenFunction::emitClassConstructorAllocator(ConstructorDecl *ctor) {
     // allocated is the type of the class that defines the designated
     // initializer.
     F.setIsExactSelfClass(IsExactSelfClass);
-    selfValue = B.createAllocRef(Loc, selfTy, useObjCAllocation, false,
+    selfValue = B.createAllocRef(Loc, selfTy, useObjCAllocation, false, false,
                                  ArrayRef<SILType>(), ArrayRef<SILValue>());
   }
   args.push_back(selfValue);
diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp
@@ -1781,6 +1781,7 @@ visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI) {
 
     NewInst = Builder.createAllocRef(ARDI->getLoc(), SILInstanceTy,
                                      ARDI->isObjC(), ARDI->canAllocOnStack(),
+                                     /*isBare=*/ false,
                                      ARDI->getTailAllocatedTypes(),
                                      getCounts(ARDI));
 
@@ -1806,6 +1807,7 @@ visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI) {
         return nullptr;
       NewInst = Builder.createAllocRef(ARDI->getLoc(), SILInstanceTy,
                                        ARDI->isObjC(), ARDI->canAllocOnStack(),
+                                       /*isBare=*/ false,
                                        ARDI->getTailAllocatedTypes(),
                                        getCounts(ARDI));
     }
@@ -1833,6 +1835,7 @@ visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI) {
       return nullptr;
     NewInst = Builder.createAllocRef(
         ARDI->getLoc(), *instanceTy, ARDI->isObjC(), false,
+        /*isBare=*/ false,
         ARDI->getTailAllocatedTypes(), getCounts(ARDI));
     NewInst = Builder.createUncheckedRefCast(ARDI->getLoc(), NewInst,
                                              ARDI->getType());
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1702,7 +1702,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
                                                  TailTypes, Counts);
     } else {
       assert(i == NumVals);
-      ResultInst = Builder.createAllocRef(Loc, ClassTy, isObjC, canAllocOnStack,
+      bool isBare = (bool)((Flags >> 2) & 1);
+      ResultInst = Builder.createAllocRef(Loc, ClassTy, isObjC, canAllocOnStack, isBare,
                                           TailTypes, Counts);
     }
     break;
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1057,8 +1057,12 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     const AllocRefInstBase *ARI = cast<AllocRefInstBase>(&SI);
     unsigned abbrCode = SILAbbrCodes[SILOneTypeValuesLayout::Code];
     SmallVector<ValueID, 4> Args;
+    bool isBare = false;
+    if (auto *ar = dyn_cast<AllocRefInst>(&SI))
+      isBare = ar->isBare();
     Args.push_back((unsigned)ARI->isObjC() |
-                   ((unsigned)ARI->canAllocOnStack() << 1));
+                   ((unsigned)ARI->canAllocOnStack() << 1) |
+                   ((unsigned)isBare << 2));
     ArrayRef<SILType> TailTypes = ARI->getTailAllocatedTypes();
     ArrayRef<Operand> AllOps = ARI->getAllOperands();
     unsigned NumTailAllocs = TailTypes.size();
diff --git a/test/SIL/Parser/basic.sil b/test/SIL/Parser/basic.sil
@@ -758,6 +758,15 @@ bb0:
   return %2 : $()
 }
 
+// CHECK-LABEL: sil @test_bare_flags
+sil @test_bare_flags : $@convention(thin) () -> () {
+bb0:
+  // CHECK: alloc_ref [bare] $Class1
+  %0 = alloc_ref [bare] $Class1
+  %2 = tuple ()
+  return %2 : $()
+}
+
 // CHECK-LABEL: sil @test_stack_protection_flags
 sil @test_stack_protection_flags : $@convention(thin) (@inout Builtin.Word) -> () {
 bb0(%0 : $*Builtin.Word):
diff --git a/test/Serialization/Inputs/def_basic.sil b/test/Serialization/Inputs/def_basic.sil
@@ -684,6 +684,15 @@ bb0:
   return %2 : $()
 }
 
+// CHECK-LABEL: sil public_external [transparent] @test_bare_flags
+sil [transparent] [serialized] @test_bare_flags : $@convention(thin) () -> () {
+bb0:
+  // CHECK: alloc_ref [bare] $Class1
+  %0 = alloc_ref [bare] $Class1
+  %2 = tuple ()
+  return %2 : $()
+}
+
 // CHECK-LABEL: sil public_external [transparent] @test_stack_protection_flags
 sil [transparent] [serialized] @test_stack_protection_flags : $@convention(thin) (@inout Builtin.Word) -> () {
 bb0(%0 : $*Builtin.Word):
@@ -1537,7 +1546,8 @@ bb0:
   %84 = function_ref @test_dealloc_partial_ref : $@convention(thin) () -> ()
   %85 = function_ref @test_dealloc_box : $@convention(thin) () -> ()
   %86 = function_ref @test_stack_flag : $@convention(thin) () -> ()
-  %86b = function_ref @test_stack_protection_flags : $@convention(thin) (@inout Builtin.Word) -> ()
+  %86b = function_ref @test_bare_flags : $@convention(thin) () -> ()
+  %86c = function_ref @test_stack_protection_flags : $@convention(thin) (@inout Builtin.Word) -> ()
   %87 = function_ref @test_tail_elems : $@convention(thin) (Builtin.Word, Builtin.Word) -> ()
   %88 = function_ref @test_tail_elems_dynamic : $@convention(thin) (Builtin.Word, Builtin.Word, @thick Class1.Type) -> ()
   %89 = function_ref @test_tail_addr : $@convention(thin) (@owned Class1, Builtin.Word) -> @owned Class1

Original file line number	Diff line number	Diff line change
`@@ -430,6 +430,14 @@ extension RefCountingInst {`
`430`	`430`	`}`
`431`	`431`	`}`
`432`	`432`
	`433`	`+extension AllocRefInst {`
	`434`	`+ func setIsBare(_ context: some MutatingContext) {`
	`435`	`+ context.notifyInstructionsChanged()`
	`436`	`+ bridged.AllocRefInst_setIsBare()`
	`437`	`+ context.notifyInstructionChanged(self)`
	`438`	`+ }`
	`439`	`+}`
	`440`	`+`
`433`	`441`	`extension TermInst {`
`434`	`442`	`func replaceBranchTarget(from fromBlock: BasicBlock, to toBlock: BasicBlock, _ context: some MutatingContext) {`
`435`	`443`	`context.notifyBranchesChanged()`
Original file line number	Diff line number	Diff line change
`@@ -837,6 +837,7 @@ public class AllocRefInstBase : SingleValueInstruction, Allocation {`
`837`	`837`	`}`
`838`	`838`
`839`	`839`	`final public class AllocRefInst : AllocRefInstBase {`
	`840`	`+ public var isBare: Bool { bridged.AllocRefInst_isBare() }`
`840`	`841`	`}`
`841`	`842`
`842`	`843`	`final public class AllocRefDynamicInst : AllocRefInstBase {`
Original file line number	Diff line number	Diff line change
`@@ -922,7 +922,7 @@ SILCloner<ImplClass>::visitAllocRefInst(AllocRefInst *Inst) {`
`922`	`922`	`}`
`923`	`923`	`auto *NewInst = getBuilder().createAllocRef(getOpLocation(Inst->getLoc()),`
`924`	`924`	`getOpType(Inst->getType()),`
`925`		`- Inst->isObjC(), Inst->canAllocOnStack(),`
	`925`	`+ Inst->isObjC(), Inst->canAllocOnStack(), Inst->isBare(),`
`926`	`926`	`ElemTypes, CountArgs);`
`927`	`927`	`recordClonedInstruction(Inst, NewInst);`
`928`	`928`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1452,6 +1452,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {`
`1452`	`1452`	`}`
`1453`	`1453`
`1454`	`1454`	`void visitAllocRefInst(AllocRefInst *ARI) {`
	`1455`	`+ if (ARI->isBare())`
	`1456`	`+ *this << "[bare] ";`
`1455`	`1457`	`printAllocRefInstBase(ARI);`
`1456`	`1458`	`*this << ARI->getType();`
`1457`	`1459`	`}`