SIL: add a dependency token operand to global_addr

eeckstein · eeckstein · commit bc99986cf9cc · 2024-01-10T09:33:58.000+01:00
Optionally, the dependency to the initialization of the global can be specified with a dependency token `depends_on &lt;token&gt;`.
This is usually a `builtin "once"` which calls the initializer for the global variable.
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift
@@ -246,7 +246,7 @@ private func createOutlinedGlobal(
   }
 
   let builder = Builder(before: allocVectorBuiltin, context)
-  let globalAddr = builder.createGlobalAddr(global: outlinedGlobal)
+  let globalAddr = builder.createGlobalAddr(global: outlinedGlobal, dependencyToken: nil)
   let rawVectorPointer = builder.createAddressToPointer(address: globalAddr, pointerType: allocVectorBuiltin.type,
                                                         needStackProtection: false)
   allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift
@@ -503,7 +503,7 @@ private func replace(findStringCall: ApplyInst,
   _ = varBuilder.createStruct(type: cacheType, elements: [zero, zero])
 
   let builder = Builder(before: findStringCall, context)
-  let cacheAddr = builder.createGlobalAddr(global: cacheVar)
+  let cacheAddr = builder.createGlobalAddr(global: cacheVar, dependencyToken: nil)
   let findStringRef = builder.createFunctionRef(cachedFindStringFunc)
   let newCall = builder.createApply(function: findStringRef, SubstitutionMap(),
                                     arguments: [findStringCall.arguments[0],
diff --git a/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift b/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift
@@ -109,6 +109,10 @@ private extension BuiltinInst {
     if callee.instructions.contains(where: hasSideEffectForBuiltinOnce) {
       return
     }
+    for use in uses {
+      let ga = use.instruction as! GlobalAddrInst
+      ga.clearToken(context)
+    }
     context.erase(instruction: self)
   }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift b/SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift
@@ -110,6 +110,8 @@ extension LoadInst : OnoneSimplifyable, SILCombineSimplifyable {
     let initVal = cloner.clone(globalInitVal)
 
     uses.replaceAll(with: initVal, context)
+    // Also erases a builtin "once" on which the global_addr depends on. This is fine
+    // because we only replace the load if the global init function doesn't have any side effect.
     transitivelyErase(load: self, context)
     return true
   }
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift
@@ -535,6 +535,14 @@ extension RefElementAddrInst {
   }
 }
 
+extension GlobalAddrInst {
+  func clearToken(_ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.GlobalAddrInst_clearToken()
+    context.notifyInstructionChanged(self)
+  }
+}
+
 extension GlobalValueInst {
   func setIsBare(_ context: some MutatingContext) {
     context.notifyInstructionsChanged()
diff --git a/SwiftCompilerSources/Sources/SIL/Builder.swift b/SwiftCompilerSources/Sources/SIL/Builder.swift
@@ -305,8 +305,8 @@ public struct Builder {
     return notifyNew(vectorInst.getAs(VectorInst.self))
   }
 
-  public func createGlobalAddr(global: GlobalVariable) -> GlobalAddrInst {
-    return notifyNew(bridged.createGlobalAddr(global.bridged).getAs(GlobalAddrInst.self))
+  public func createGlobalAddr(global: GlobalVariable, dependencyToken: Value?) -> GlobalAddrInst {
+    return notifyNew(bridged.createGlobalAddr(global.bridged, dependencyToken.bridged).getAs(GlobalAddrInst.self))
   }
 
   public func createGlobalValue(global: GlobalVariable, isBare: Bool) -> GlobalValueInst {
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift
@@ -650,6 +650,10 @@ final public class GlobalAddrInst : GlobalAccessInst, VarDeclInstruction {
   public var varDecl: VarDecl? {
     VarDecl(bridged: bridged.GlobalAddr_getDecl())
   }
+
+  public var dependencyToken: Value? {
+    operands.count == 1 ? operands[0].value : nil
+  }
 }
 
 final public class GlobalValueInst : GlobalAccessInst {
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -5739,15 +5739,21 @@ global_addr
 
 ::
 
-  sil-instruction ::= 'global_addr' sil-global-name ':' sil-type
+  sil-instruction ::= 'global_addr' sil-global-name ':' sil-type ('depends_on' sil-operand)?
 
   %1 = global_addr @foo : $*Builtin.Word
+  %3 = global_addr @globalvar : $*Builtin.Word depends_on %2
+  // %2 has type $Builtin.SILToken
 
 Creates a reference to the address of a global variable which has been
 previously initialized 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.
 
+Optionally, the dependency to the initialization of the global can be
+specified with a dependency token ``depends_on <token>``. This is usually
+a ``builtin "once"`` which calls the initializer for the global variable.
+
 global_value
 `````````````
 ::
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -1502,6 +1502,9 @@ WARNING(warning_in_effects_attribute,none,
 ERROR(expected_in_attribute_list,none,
       "expected ']' or ',' in attribute list", ())
 
+ERROR(expected_depends_on,none,
+      "expected 'depends_on'", ())
+
 ERROR(type_attribute_applied_to_decl,none,
       "attribute can only be applied to types, not declarations", ())
 ERROR(decl_attribute_applied_to_type,none,
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -809,6 +809,7 @@ struct BridgedInstruction {
   BRIDGED_INLINE void TermInst_replaceBranchTarget(BridgedBasicBlock from, BridgedBasicBlock to) const;
   BRIDGED_INLINE SwiftInt KeyPathInst_getNumComponents() const;
   BRIDGED_INLINE void KeyPathInst_getReferencedFunctions(SwiftInt componentIdx, KeyPathFunctionResults * _Nonnull results) const;
+  BRIDGED_INLINE void GlobalAddrInst_clearToken() const;
   BRIDGED_INLINE bool GlobalValueInst_isBare() const;
   BRIDGED_INLINE void GlobalValueInst_setIsBare() const;
   BRIDGED_INLINE void LoadInst_setOwnership(SwiftInt ownership) const;
@@ -1093,7 +1094,8 @@ struct BridgedBuilder{
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createObject(BridgedType type, BridgedValueArray arguments,
                                                                      SwiftInt numBaseElements) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createVector(BridgedValueArray arguments) const;
-  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalAddr(BridgedGlobalVar global) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalAddr(BridgedGlobalVar global,
+                                                                         OptionalBridgedValue dependencyToken) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalValue(BridgedGlobalVar global,
                                                                           bool isBare) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createStruct(BridgedType type,
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -1114,6 +1114,10 @@ void BridgedInstruction::KeyPathInst_getReferencedFunctions(SwiftInt componentId
     }, [](swift::SILDeclRef) {});
 }
 
+void BridgedInstruction::GlobalAddrInst_clearToken() const {
+  getAs<swift::GlobalAddrInst>()->clearToken();
+}
+
 bool BridgedInstruction::GlobalValueInst_isBare() const {
   return getAs<swift::GlobalValueInst>()->isBare();
 }
@@ -1522,8 +1526,9 @@ BridgedInstruction BridgedBuilder::createVector(BridgedValueArray arguments) con
   return {unbridged().createVector(swift::ArtificialUnreachableLocation(), arguments.getValues(argValues))};
 }
 
-BridgedInstruction BridgedBuilder::createGlobalAddr(BridgedGlobalVar global) const {
-  return {unbridged().createGlobalAddr(regularLoc(), global.getGlobal())};
+BridgedInstruction BridgedBuilder::createGlobalAddr(BridgedGlobalVar global,
+                                                    OptionalBridgedValue dependencyToken) const {
+  return {unbridged().createGlobalAddr(regularLoc(), global.getGlobal(), dependencyToken.getSILValue())};
 }
 
 BridgedInstruction BridgedBuilder::createGlobalValue(BridgedGlobalVar global, bool isBare) const {
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -680,14 +680,12 @@ class SILBuilder {
     return insert(new (getModule())
                       AllocGlobalInst(getSILDebugLocation(Loc), g));
   }
-  GlobalAddrInst *createGlobalAddr(SILLocation Loc, SILGlobalVariable *g) {
+  GlobalAddrInst *createGlobalAddr(SILLocation Loc, SILGlobalVariable *g,
+                                   SILValue dependencyToken) {
     return insert(new (getModule()) GlobalAddrInst(getSILDebugLocation(Loc), g,
+                                                   dependencyToken,
                                                    getTypeExpansionContext()));
   }
-  GlobalAddrInst *createGlobalAddr(SILLocation Loc, SILType Ty) {
-    return insert(new (F->getModule())
-                  GlobalAddrInst(getSILDebugLocation(Loc), Ty));
-  }
   GlobalValueInst *createGlobalValue(SILLocation Loc, SILGlobalVariable *g, bool isBare) {
     return insert(new (getModule()) GlobalValueInst(getSILDebugLocation(Loc), g,
                                                     getTypeExpansionContext(), isBare));
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -1124,7 +1124,10 @@ SILCloner<ImplClass>::visitGlobalAddrInst(GlobalAddrInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
       Inst, getBuilder().createGlobalAddr(getOpLocation(Inst->getLoc()),
-                                          Inst->getReferencedGlobal()));
+                                          Inst->getReferencedGlobal(),
+                                          Inst->hasOperand() ?
+                                            getOpValue(Inst->getDependencyToken()) :
+                                            SILValue()));
 }
 
 template<typename ImplClass>
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -4176,15 +4176,43 @@ class GlobalAddrInst
   friend SILBuilder;
 
   GlobalAddrInst(SILDebugLocation DebugLoc, SILGlobalVariable *Global,
+                 SILValue dependencyToken,
                  TypeExpansionContext context);
 
+  llvm::Optional<FixedOperandList<1>> dependencyToken;
+
 public:
   // FIXME: This constructor should be private but is currently used
   //        in the SILParser.
 
   /// Create a placeholder instruction with an unset global reference.
   GlobalAddrInst(SILDebugLocation DebugLoc, SILType Ty)
       : InstructionBase(DebugLoc, Ty, nullptr) {}
+
+  SILValue getDependencyToken() const {
+    if (hasOperand())
+      return getOperand();
+    return SILValue();
+  }
+
+  void clearToken() {
+    dependencyToken = llvm::None;
+  }
+
+  bool hasOperand() const { return dependencyToken.has_value(); }
+  SILValue getOperand() const { return dependencyToken->asValueArray()[0]; }
+
+  Operand &getOperandRef() { return dependencyToken->asArray()[0]; }
+  const Operand &getOperandRef() const { return dependencyToken->asArray()[0]; }
+
+  ArrayRef<Operand> getAllOperands() const {
+    return dependencyToken ? dependencyToken->asArray() : ArrayRef<Operand>{};
+  }
+
+  MutableArrayRef<Operand> getAllOperands() {
+    return dependencyToken
+      ? dependencyToken->asArray() : MutableArrayRef<Operand>{};
+  }
 };
 
 /// Creates a base address for offset calculations.
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1925,9 +1925,11 @@ static ValueDecl *getOnceOperation(ASTContext &Context,
           .build();
   auto BlockTy = FunctionType::get(CFuncParams, VoidTy, Thin);
   SmallVector<swift::Type, 3> ArgTypes = {HandleTy, BlockTy};
-  if (withContext)
+  if (withContext) {
     ArgTypes.push_back(ContextTy);
-  return getBuiltinFunction(Id, ArgTypes, VoidTy);
+    return getBuiltinFunction(Id, ArgTypes, VoidTy);
+  }
+  return getBuiltinFunction(Id, ArgTypes, Context.TheSILTokenType);
 }
 
 static ValueDecl *getPolymorphicBinaryOperation(ASTContext &ctx,
diff --git a/lib/IRGen/LoadableByAddress.cpp b/lib/IRGen/LoadableByAddress.cpp
@@ -3164,7 +3164,8 @@ void LoadableByAddress::run() {
     } else if (auto *globalAddr = dyn_cast<GlobalAddrInst>(inst)) {
       SILBuilderWithScope builder(inst);
       auto *newInst = builder.createGlobalAddr(
-          globalAddr->getLoc(), globalAddr->getReferencedGlobal());
+          globalAddr->getLoc(), globalAddr->getReferencedGlobal(),
+          globalAddr->getDependencyToken());
       globalAddr->replaceAllUsesWith(newInst);
       globalAddr->eraseFromParent();
     } else if (auto *globalVal = dyn_cast<GlobalValueInst>(inst)) {
diff --git a/lib/SIL/IR/OperandOwnership.cpp b/lib/SIL/IR/OperandOwnership.cpp
@@ -107,7 +107,6 @@ SHOULD_NEVER_VISIT_INST(FunctionRef)
 SHOULD_NEVER_VISIT_INST(DebugStep)
 SHOULD_NEVER_VISIT_INST(DynamicFunctionRef)
 SHOULD_NEVER_VISIT_INST(PreviousDynamicFunctionRef)
-SHOULD_NEVER_VISIT_INST(GlobalAddr)
 SHOULD_NEVER_VISIT_INST(GlobalValue)
 SHOULD_NEVER_VISIT_INST(BaseAddrForOffset)
 SHOULD_NEVER_VISIT_INST(HasSymbol)
@@ -207,6 +206,7 @@ OPERAND_OWNERSHIP(TrivialUse, PackPackIndex)
 OPERAND_OWNERSHIP(TrivialUse, PackElementGet)
 OPERAND_OWNERSHIP(TrivialUse, PackElementSet)
 OPERAND_OWNERSHIP(TrivialUse, TuplePackElementAddr)
+OPERAND_OWNERSHIP(TrivialUse, GlobalAddr)
 
 // The dealloc_stack_ref operand needs to have NonUse ownership because
 // this use comes after the last consuming use (which is usually a dealloc_ref).
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -1038,10 +1038,15 @@ AllocGlobalInst::AllocGlobalInst(SILDebugLocation Loc,
 
 GlobalAddrInst::GlobalAddrInst(SILDebugLocation DebugLoc,
                                SILGlobalVariable *Global,
+                               SILValue dependencyToken,
                                TypeExpansionContext context)
     : InstructionBase(DebugLoc,
                       Global->getLoweredTypeInContext(context).getAddressType(),
-                      Global) {}
+                      Global) {
+  if (dependencyToken) {
+    this->dependencyToken.emplace(this, dependencyToken);
+  }
+}
 
 GlobalValueInst::GlobalValueInst(SILDebugLocation DebugLoc,
                                  SILGlobalVariable *Global,
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1644,6 +1644,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "<<placeholder>>";
     }
     *this << " : " << GAI->getType();
+    if (SILValue token = GAI->getDependencyToken()) {
+      *this << " depends_on " <<  Ctx.getID(token);
+    }
   }
 
   void visitGlobalValueInst(GlobalValueInst *GVI) {
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -5671,7 +5671,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
           parseSILIdentifier(GlobalName, IdLoc,
                              diag::expected_sil_value_name) ||
           P.parseToken(tok::colon, diag::expected_tok_in_sil_instr, ":") ||
-          parseSILType(Ty) || parseSILDebugLocation(InstLoc, B))
+          parseSILType(Ty))
         return true;
 
       // Go through list of global variables in the SILModule.
@@ -5681,6 +5681,18 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         return true;
       }
 
+      SILValue dependencyToken;
+      if (Opcode == SILInstructionKind::GlobalAddrInst && P.Tok.isContextualKeyword("depends_on")) {
+        P.consumeToken();
+        if (parseValueRef(dependencyToken, SILType::getSILTokenType(P.Context),
+                          RegularLocation(P.Tok.getLoc()), B)) {
+          return true;
+        }
+      }
+
+      if (parseSILDebugLocation(InstLoc, B))
+        return true;
+
       SILType expectedType = (Opcode == SILInstructionKind::GlobalAddrInst
                                   ? global->getLoweredType().getAddressType()
                                   : global->getLoweredType());
@@ -5692,7 +5704,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       }
 
       if (Opcode == SILInstructionKind::GlobalAddrInst) {
-        ResultVal = B.createGlobalAddr(InstLoc, global);
+        ResultVal = B.createGlobalAddr(InstLoc, global, dependencyToken);
       } else {
         ResultVal = B.createGlobalValue(InstLoc, global, isBare);
       }
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -1515,6 +1515,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     if (isa<OpenPackElementInst>(value))
       return true;
 
+    if (auto *bi = dyn_cast<BuiltinInst>(value)) {
+      if (bi->getBuiltinInfo().ID == BuiltinValueKind::Once)
+        return true;
+    }
+
     // Add more token cases here as they arise.
 
     return false;
@@ -2297,6 +2302,10 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "global_addr cannot refer to a statically initialized object");
     checkGlobalAccessInst(GAI);
     checkAddressWalkerCanVisitAllTransitiveUses(GAI);
+    if (SILValue token = GAI->getDependencyToken()) {
+      require(token->getType().is<SILTokenType>(),
+              "depends_on operand of global_addr must be a token");
+    }
   }
 
   void checkGlobalValueInst(GlobalValueInst *GVI) {
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
@@ -1480,7 +1480,7 @@ SILGenFunction::emitInitializationForVarDecl(VarDecl *vd, bool forceImmutable,
     RegularLocation loc(vd);
     loc.markAutoGenerated();
     B.createAllocGlobal(loc, silG);
-    SILValue addr = B.createGlobalAddr(loc, silG);
+    SILValue addr = B.createGlobalAddr(loc, silG, /*dependencyToken=*/ SILValue());
     if (isUninitialized)
       addr = B.createMarkUninitializedVar(loc, addr);
 
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -4344,14 +4344,14 @@ visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *E, SGFContext C) {
             SILGlobalVariable::create(M, SILLinkage::DefaultForDeclaration,
                                       IsNotSerialized, "__ImageBase",
                                       BuiltinRawPtrTy);
-      ModuleBase = B.createGlobalAddr(SILLoc, ImageBase);
+      ModuleBase = B.createGlobalAddr(SILLoc, ImageBase, /*dependencyToken=*/ SILValue());
     } else {
       auto DSOHandle = M.lookUpGlobalVariable("__dso_handle");
       if (!DSOHandle)
         DSOHandle = SILGlobalVariable::create(M, SILLinkage::PublicExternal,
                                               IsNotSerialized, "__dso_handle",
                                               BuiltinRawPtrTy);
-      ModuleBase = B.createGlobalAddr(SILLoc, DSOHandle);
+      ModuleBase = B.createGlobalAddr(SILLoc, DSOHandle, /*dependencyToken=*/ SILValue());
     }
 
     auto ModuleBasePointer =
diff --git a/lib/SILGen/SILGenGlobalVariable.cpp b/lib/SILGen/SILGenGlobalVariable.cpp
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
diff --git a/test/SIL/Parser/basic.sil b/test/SIL/Parser/basic.sil
diff --git a/test/SILGen/lazy_globals.swift b/test/SILGen/lazy_globals.swift
diff --git a/test/SILOptimizer/simplify_builtin.sil b/test/SILOptimizer/simplify_builtin.sil
diff --git a/test/Serialization/Inputs/def_basic.sil b/test/Serialization/Inputs/def_basic.sil

Original file line number	Diff line number	Diff line change
`@@ -246,7 +246,7 @@ private func createOutlinedGlobal(`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`let builder = Builder(before: allocVectorBuiltin, context)`
`249`		`- let globalAddr = builder.createGlobalAddr(global: outlinedGlobal)`
	`249`	`+ let globalAddr = builder.createGlobalAddr(global: outlinedGlobal, dependencyToken: nil)`
`250`	`250`	`let rawVectorPointer = builder.createAddressToPointer(address: globalAddr, pointerType: allocVectorBuiltin.type,`
`251`	`251`	`needStackProtection: false)`
`252`	`252`	`allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)`
Original file line number	Diff line number	Diff line change
`@@ -109,6 +109,10 @@ private extension BuiltinInst {`
`109`	`109`	`if callee.instructions.contains(where: hasSideEffectForBuiltinOnce) {`
`110`	`110`	`return`
`111`	`111`	`}`
	`112`	`+ for use in uses {`
	`113`	`+ let ga = use.instruction as! GlobalAddrInst`
	`114`	`+ ga.clearToken(context)`
	`115`	`+ }`
`112`	`116`	`context.erase(instruction: self)`
`113`	`117`	`}`
`114`	`118`
Original file line number	Diff line number	Diff line change
`@@ -110,6 +110,8 @@ extension LoadInst : OnoneSimplifyable, SILCombineSimplifyable {`
`110`	`110`	`let initVal = cloner.clone(globalInitVal)`
`111`	`111`
`112`	`112`	`uses.replaceAll(with: initVal, context)`
	`113`	`+ // Also erases a builtin "once" on which the global_addr depends on. This is fine`
	`114`	`+ // because we only replace the load if the global init function doesn't have any side effect.`
`113`	`115`	`transitivelyErase(load: self, context)`
`114`	`116`	`return true`
`115`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -535,6 +535,14 @@ extension RefElementAddrInst {`
`535`	`535`	`}`
`536`	`536`	`}`
`537`	`537`
	`538`	`+extension GlobalAddrInst {`
	`539`	`+ func clearToken(_ context: some MutatingContext) {`
	`540`	`+ context.notifyInstructionsChanged()`
	`541`	`+ bridged.GlobalAddrInst_clearToken()`
	`542`	`+ context.notifyInstructionChanged(self)`
	`543`	`+ }`
	`544`	`+}`
	`545`	`+`
`538`	`546`	`extension GlobalValueInst {`
`539`	`547`	`func setIsBare(_ context: some MutatingContext) {`
`540`	`548`	`context.notifyInstructionsChanged()`
Original file line number	Diff line number	Diff line change
`@@ -305,8 +305,8 @@ public struct Builder {`
`305`	`305`	`return notifyNew(vectorInst.getAs(VectorInst.self))`
`306`	`306`	`}`
`307`	`307`
`308`		`- public func createGlobalAddr(global: GlobalVariable) -> GlobalAddrInst {`
`309`		`- return notifyNew(bridged.createGlobalAddr(global.bridged).getAs(GlobalAddrInst.self))`
	`308`	`+ public func createGlobalAddr(global: GlobalVariable, dependencyToken: Value?) -> GlobalAddrInst {`
	`309`	`+ return notifyNew(bridged.createGlobalAddr(global.bridged, dependencyToken.bridged).getAs(GlobalAddrInst.self))`
`310`	`310`	`}`
`311`	`311`
`312`	`312`	`public func createGlobalValue(global: GlobalVariable, isBare: Bool) -> GlobalValueInst {`
Original file line number	Diff line number	Diff line change
`@@ -650,6 +650,10 @@ final public class GlobalAddrInst : GlobalAccessInst, VarDeclInstruction {`
`650`	`650`	`public var varDecl: VarDecl? {`
`651`	`651`	`VarDecl(bridged: bridged.GlobalAddr_getDecl())`
`652`	`652`	`}`
	`653`	`+`
	`654`	`+ public var dependencyToken: Value? {`
	`655`	`+ operands.count == 1 ? operands[0].value : nil`
	`656`	`+ }`
`653`	`657`	`}`
`654`	`658`
`655`	`659`	`final public class GlobalValueInst : GlobalAccessInst {`