SIL: add a bare attribute to global_value

eeckstein · eeckstein · commit 625619ee1722 · 2023-06-29T06:57:05.000+02:00
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.
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift b/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)
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift
@@ -438,6 +438,14 @@ extension AllocRefInst {
   }
 }
 
+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()
diff --git a/SwiftCompilerSources/Sources/SIL/Builder.swift b/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 {
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/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 {
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -5490,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
 
@@ -5499,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
 ```````````````
 ::
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -794,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;
 
@@ -1250,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
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -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())
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -1125,7 +1125,8 @@ SILCloner<ImplClass>::visitGlobalValueInst(GlobalValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
       Inst, getBuilder().createGlobalValue(getOpLocation(Inst->getLoc()),
-                                           Inst->getReferencedGlobal()));
+                                           Inst->getReferencedGlobal(),
+                                           Inst->isBare()));
 }
 
 template<typename ImplClass>
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -4119,9 +4119,18 @@ class GlobalValueInst
     : public InstructionBase<SILInstructionKind::GlobalValueInst,
                              GlobalAccessInst> {
   friend SILBuilder;
+  USE_SHARED_UINT8;
 
   GlobalValueInst(SILDebugLocation DebugLoc, SILGlobalVariable *Global,
-                  TypeExpansionContext context);
+                  TypeExpansionContext context, bool isBare);
+public:
+  bool isBare() const {
+    return sharedUInt8().GlobalValueInst.isBare;
+  }
+
+  void setBare(bool isBare = true) {
+    sharedUInt8().GlobalValueInst.isBare = isBare;
+  }
 };
 
 /// IntegerLiteralInst - Encapsulates an integer constant, as defined originally
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -202,6 +202,7 @@ class alignas(8) SILNode :
     SHARED_FIELD(EndCOWMutationInst, bool keepUnique);
     SHARED_FIELD(ConvertFunctionInst, bool withoutActuallyEscaping);
     SHARED_FIELD(BeginCOWMutationInst, bool native);
+    SHARED_FIELD(GlobalValueInst, bool isBare);
 
     SHARED_FIELD(SILArgument, uint8_t
                  valueOwnershipKind : NumVOKindBits,
diff --git a/lib/IRGen/LoadableByAddress.cpp b/lib/IRGen/LoadableByAddress.cpp
@@ -3168,7 +3168,7 @@ void LoadableByAddress::run() {
     } else if (auto *globalVal = dyn_cast<GlobalValueInst>(inst)) {
       SILBuilderWithScope builder(inst);
       auto *newInst = builder.createGlobalValue(
-          globalVal->getLoc(), globalVal->getReferencedGlobal());
+          globalVal->getLoc(), globalVal->getReferencedGlobal(), globalVal->isBare());
       globalVal->replaceAllUsesWith(newInst);
       globalVal->eraseFromParent();
     }
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -1019,10 +1019,12 @@ GlobalAddrInst::GlobalAddrInst(SILDebugLocation DebugLoc,
 
 GlobalValueInst::GlobalValueInst(SILDebugLocation DebugLoc,
                                  SILGlobalVariable *Global,
-                                 TypeExpansionContext context)
+                                 TypeExpansionContext context, bool bare)
     : InstructionBase(DebugLoc,
                       Global->getLoweredTypeInContext(context).getObjectType(),
-                      Global) {}
+                      Global) {
+  sharedUInt8().GlobalValueInst.isBare = bare;
+}
 
 const IntrinsicInfo &BuiltinInst::getIntrinsicInfo() const {
   return getModule().getIntrinsicInfo(getName());
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1624,6 +1624,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   }
 
   void visitGlobalValueInst(GlobalValueInst *GVI) {
+    if (GVI->isBare())
+      *this << "[bare] ";
     GVI->getReferencedGlobal()->printName(PrintState.OS);
     *this << " : " << GVI->getType();
   }
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -5850,6 +5850,19 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       Identifier GlobalName;
       SourceLoc IdLoc;
       SILType Ty;
+      bool isBare = false;
+      if (P.consumeIf(tok::l_square)) {
+        Identifier Id;
+        parseSILIdentifier(Id, diag::expected_in_attribute_list);
+        StringRef Optional = Id.str();
+        if (Optional == "bare" && Opcode == SILInstructionKind::GlobalValueInst) {
+          isBare = true;
+        } else {
+          return true;
+        }
+        P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+      }
+
       if (P.parseToken(tok::at_sign, diag::expected_sil_value_name) ||
           parseSILIdentifier(GlobalName, IdLoc,
                              diag::expected_sil_value_name) ||
@@ -5877,7 +5890,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       if (Opcode == SILInstructionKind::GlobalAddrInst) {
         ResultVal = B.createGlobalAddr(InstLoc, global);
       } else {
-        ResultVal = B.createGlobalValue(InstLoc, global);
+        ResultVal = B.createGlobalValue(InstLoc, global, isBare);
       }
       break;
     }
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1854,7 +1854,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     if (OpCode == SILInstructionKind::GlobalAddrInst) {
       ResultInst = Builder.createGlobalAddr(Loc, g);
     } else {
-      ResultInst = Builder.createGlobalValue(Loc, g);
+      ResultInst = Builder.createGlobalValue(Loc, g, /*isBare=*/ (Attr & 1) != 0);
     }
     break;
   }
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1254,9 +1254,12 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     const GlobalAccessInst *GI = cast<GlobalAccessInst>(&SI);
     auto *G = GI->getReferencedGlobal();
     addReferencedGlobalVariable(G);
+    bool isBare = false;
+    if (auto *gv = dyn_cast<GlobalValueInst>(&SI))
+      isBare = gv->isBare();
     SILOneOperandLayout::emitRecord(Out, ScratchRecord,
         SILAbbrCodes[SILOneOperandLayout::Code],
-        (unsigned)SI.getKind(), 0,
+        (unsigned)SI.getKind(), isBare ? 1 : 0,
         S.addTypeRef(GI->getType().getRawASTType()),
         (unsigned)GI->getType().getCategory(),
         S.addUniquedStringRef(G->getName()));
diff --git a/test/SIL/Parser/basic.sil b/test/SIL/Parser/basic.sil
@@ -763,6 +763,8 @@ sil @test_bare_flags : $@convention(thin) () -> () {
 bb0:
   // CHECK: alloc_ref [bare] $Class1
   %0 = alloc_ref [bare] $Class1
+  // CHECK: global_value [bare] @static_array : $TestArrayStorage
+  %1 = global_value [bare] @static_array : $TestArrayStorage
   %2 = tuple ()
   return %2 : $()
 }
diff --git a/test/Serialization/Inputs/def_basic.sil b/test/Serialization/Inputs/def_basic.sil
@@ -689,6 +689,8 @@ sil [transparent] [serialized] @test_bare_flags : $@convention(thin) () -> () {
 bb0:
   // CHECK: alloc_ref [bare] $Class1
   %0 = alloc_ref [bare] $Class1
+  // CHECK: global_value [bare] @static_global_object : $GlobalObject
+  %1 = global_value [bare] @static_global_object : $GlobalObject
   %2 = tuple ()
   return %2 : $()
 }

Original file line number	Diff line number	Diff line change
`@@ -438,6 +438,14 @@ extension AllocRefInst {`
`438`	`438`	`}`
`439`	`439`	`}`
`440`	`440`
	`441`	`+extension GlobalValueInst {`
	`442`	`+ func setIsBare(_ context: some MutatingContext) {`
	`443`	`+ context.notifyInstructionsChanged()`
	`444`	`+ bridged.GlobalValueInst_setIsBare()`
	`445`	`+ context.notifyInstructionChanged(self)`
	`446`	`+ }`
	`447`	`+}`
	`448`	`+`
`441`	`449`	`extension TermInst {`
`442`	`450`	`func replaceBranchTarget(from fromBlock: BasicBlock, to toBlock: BasicBlock, _ context: some MutatingContext) {`
`443`	`451`	`context.notifyBranchesChanged()`
Original file line number	Diff line number	Diff line change
`@@ -239,8 +239,8 @@ public struct Builder {`
`239`	`239`	`return notifyNew(bridged.createGlobalAddr(global.bridged).getAs(GlobalAddrInst.self))`
`240`	`240`	`}`
`241`	`241`
`242`		`- public func createGlobalValue(global: GlobalVariable) -> GlobalValueInst {`
`243`		`- return notifyNew(bridged.createGlobalValue(global.bridged).getAs(GlobalValueInst.self))`
	`242`	`+ public func createGlobalValue(global: GlobalVariable, isBare: Bool) -> GlobalValueInst {`
	`243`	`+ return notifyNew(bridged.createGlobalValue(global.bridged, isBare).getAs(GlobalValueInst.self))`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`public func createStruct(type: Type, elements: [Value]) -> StructInst {`
Original file line number	Diff line number	Diff line change
`@@ -682,9 +682,9 @@ class SILBuilder {`
`682`	`682`	`return insert(new (F->getModule())`
`683`	`683`	`GlobalAddrInst(getSILDebugLocation(Loc), Ty));`
`684`	`684`	`}`
`685`		`- GlobalValueInst createGlobalValue(SILLocation Loc, SILGlobalVariable g) {`
	`685`	`+ GlobalValueInst createGlobalValue(SILLocation Loc, SILGlobalVariable g, bool isBare) {`
`686`	`686`	`return insert(new (getModule()) GlobalValueInst(getSILDebugLocation(Loc), g,`
`687`		`- getTypeExpansionContext()));`
	`687`	`+ getTypeExpansionContext(), isBare));`
`688`	`688`	`}`
`689`	`689`	`BaseAddrForOffsetInst *createBaseAddrForOffset(SILLocation Loc, SILType Ty) {`
`690`	`690`	`return insert(new (F->getModule())`
Original file line number	Diff line number	Diff line change
`@@ -1125,7 +1125,8 @@ SILCloner<ImplClass>::visitGlobalValueInst(GlobalValueInst *Inst) {`
`1125`	`1125`	`getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));`
`1126`	`1126`	`recordClonedInstruction(`
`1127`	`1127`	`Inst, getBuilder().createGlobalValue(getOpLocation(Inst->getLoc()),`
`1128`		`- Inst->getReferencedGlobal()));`
	`1128`	`+ Inst->getReferencedGlobal(),`
	`1129`	`+ Inst->isBare()));`
`1129`	`1130`	`}`
`1130`	`1131`
`1131`	`1132`	`template<typename ImplClass>`