Merge pull request #71879 from gottesmm/pr-2299957baf71ed51bddde5296979d58d7f97d91c

[sil] Ensure that all SILValues have a parent function by making it so that SILUndef is uniqued at the function instead of module level.

Author: gottesmm

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift

@@ -99,7 +99,8 @@ private func insertEndInitInstructions(
   atEndOf initRegion: InstructionRange,
   _ context: FunctionPassContext
 ) {
-  var ssaUpdater = SSAUpdater(type: markUninitialized.type, ownership: .owned, context)
+  var ssaUpdater = SSAUpdater(function: markUninitialized.parentFunction,
+                              type: markUninitialized.type, ownership: .owned, context)
   ssaUpdater.addAvailableValue(markUninitialized, in: markUninitialized.parentBlock)
 
   for endInst in initRegion.ends {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -236,7 +236,8 @@ private extension LoadInst {
 }
 
 private func replace(load: LoadInst, with availableValues: [AvailableValue], _ context: FunctionPassContext) {
-  var ssaUpdater = SSAUpdater(type: load.type, ownership: load.ownership, context)
+  var ssaUpdater = SSAUpdater(function: load.parentFunction,
+                              type: load.type, ownership: load.ownership, context)
 
   for availableValue in availableValues {
     let block = availableValue.instruction.parentBlock

SwiftCompilerSources/Sources/Optimizer/Utilities/SSAUpdater.swift

@@ -17,9 +17,11 @@ import OptimizerBridging
 struct SSAUpdater<Context: MutatingContext> {
   let context: Context
 
-  init(type: Type, ownership: Ownership, _ context: Context) {
+  init(function: Function, type: Type, ownership: Ownership,
+       _ context: Context) {
     self.context = context
-    context._bridged.SSAUpdater_initialize(type.bridged, ownership._bridged)
+    context._bridged.SSAUpdater_initialize(function.bridged, type.bridged,
+                                           ownership._bridged)
   }
 
   mutating func addAvailableValue(_ value: Value, in block: BasicBlock) {

include/swift/SIL/SILBuilder.h

@@ -200,7 +200,11 @@ class SILBuilder {
     assert(F && "cannot create this instruction without a function context");
     return *F;
   }
-  
+
+  /// If this SILBuilder is inserting into a function, return that function. If
+  /// we are inserting into a global, this returns nullptr.
+  SILFunction *maybeGetFunction() const { return F; }
+
   bool isInsertingIntoGlobal() const { return F == nullptr; }
 
   TypeExpansionContext getTypeExpansionContext() const {

include/swift/SIL/SILCloner.h

@@ -593,7 +593,7 @@ SILCloner<ImplClass>::getMappedValue(SILValue Value) {
   if (auto *U = dyn_cast<SILUndef>(Value)) {
     auto type = getOpType(U->getType());
     ValueBase *undef =
-      (type == U->getType() ? U : SILUndef::get(type, Builder.getFunction()));
+        (type == U->getType() ? U : SILUndef::get(Builder.getFunction(), type));
     return SILValue(undef);
   }
 

include/swift/SIL/SILFunction.h

@@ -40,6 +40,7 @@ class BasicBlockBitfield;
 class NodeBitfield;
 class OperandBitfield;
 class CalleeCache;
+class SILUndef;
 
 namespace Lowering {
 class TypeLowering;
@@ -211,6 +212,7 @@ class SILFunction
   friend class BasicBlockBitfield;
   friend class NodeBitfield;
   friend class OperandBitfield;
+  friend SILUndef;
 
   /// Module - The SIL module that the function belongs to.
   SILModule &Module;
@@ -329,6 +331,13 @@ class SILFunction
 
   PerformanceConstraints perfConstraints = PerformanceConstraints::None;
 
+  /// This is the set of undef values we've created, for uniquing purposes.
+  ///
+  /// We use a SmallDenseMap since in most functions, we will have only one type
+  /// of undef if we have any at all. In that case, by staying small we avoid
+  /// needing a heap allocation.
+  llvm::SmallDenseMap<SILType, SILUndef *, 1> undefValues;
+
   /// This is the number of uses of this SILFunction inside the SIL.
   /// It does not include references from debug scopes.
   unsigned RefCount = 0;
@@ -1558,6 +1567,12 @@ class SILFunction
   /// This is a fast subset of the checks performed in the SILVerifier.
   void verifyCriticalEdges() const;
 
+  /// Validate that all SILUndefs stored in the function's type -> SILUndef map
+  /// have this function as their parent function.
+  ///
+  /// Please only call this from the SILVerifier.
+  void verifySILUndefMap() const;
+
   /// Pretty-print the SILFunction.
   void dump(bool Verbose) const;
   void dump() const;

include/swift/SIL/SILModule.h

@@ -108,7 +108,6 @@ class FuncDecl;
 class IRGenOptions;
 class KeyPathPattern;
 class ModuleDecl;
-class SILUndef;
 class SourceFile;
 class SerializedSILLoader;
 class SILFunctionBuilder;
@@ -192,7 +191,6 @@ class SILModule {
   friend SILType;
   friend SILVTable;
   friend SILProperty;
-  friend SILUndef;
   friend SILWitnessTable;
   friend SILMoveOnlyDeinit;
   friend Lowering::SILGenModule;
@@ -315,9 +313,6 @@ class SILModule {
   /// This is a cache of builtin Function declarations to numeric ID mappings.
   llvm::DenseMap<Identifier, BuiltinInfo> BuiltinIDCache;
 
-  /// This is the set of undef values we've created, for uniquing purposes.
-  llvm::DenseMap<SILType, SILUndef *> UndefValues;
-
   llvm::DenseMap<std::pair<Decl *, VarDecl *>, unsigned> fieldIndices;
   llvm::DenseMap<EnumElementDecl *, unsigned> enumCaseIndices;
 

include/swift/SIL/SILNode.h

@@ -409,12 +409,13 @@ class alignas(8) SILNode :
   /// otherwise return null.
   SILBasicBlock *getParentBlock() const;
 
-  /// If this is a SILArgument or a SILInstruction get its parent function,
-  /// otherwise return null.
+  /// Returns the parent function of this value.
+  ///
+  /// Only returns nullptr if the given value's parent is a sil global variable
+  /// initializer.
   SILFunction *getFunction() const;
 
-  /// If this is a SILArgument or a SILInstruction get its parent module,
-  /// otherwise return null.
+  /// Return the parent module of this value.
   SILModule *getModule() const;
 
   /// Pretty-print the node.  If the node is an instruction, the output

include/swift/SIL/SILUndef.h

@@ -23,28 +23,36 @@ class SILInstruction;
 class SILModule;
 
 class SILUndef : public ValueBase {
-  SILUndef(SILType type);
+  /// A back pointer to the function that this SILUndef is uniqued by.
+  SILFunction *parent;
+
+  SILUndef(SILFunction *parent, SILType type);
 
 public:
   void operator=(const SILArgument &) = delete;
   void operator delete(void *, size_t) = delete;
 
-  static SILUndef *get(SILType ty, SILModule &m);
-
   /// Return a SILUndef with the same type as the passed in value.
   static SILUndef *get(SILValue value) {
-    return SILUndef::get(value->getType(), *value->getModule());
+    return SILUndef::get(value->getFunction(), value->getType());
   }
 
-  static SILUndef *get(SILType ty, const SILFunction &f);
+  static SILUndef *get(SILFunction *f, SILType ty);
+  static SILUndef *get(SILFunction &f, SILType ty) {
+    return SILUndef::get(&f, ty);
+  }
 
+  /// This is an API only used by SILSSAUpdater... please do not use it anywhere
+  /// else.
   template <class OwnerTy>
-  static SILUndef *getSentinelValue(SILType type, OwnerTy owner) {
+  static SILUndef *getSentinelValue(SILFunction *fn, OwnerTy owner,
+                                    SILType type) {
     // Ownership kind isn't used here, the value just needs to have a unique
     // address.
-    return new (*owner) SILUndef(type);
+    return new (*owner) SILUndef(fn, type);
   }
 
+  SILFunction *getParent() const { return parent; }
   ValueOwnershipKind getOwnershipKind() const { return OwnershipKind::None; }
 
   static bool classof(const SILArgument *) = delete;

include/swift/SIL/SILValue.h

@@ -1592,16 +1592,20 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, SILValue V) {
 
 /// Used internally in e.g. the SIL parser and deserializer to handle forward-
 /// referenced values.
+///
 /// A PlaceholderValue must not appear in valid SIL.
 class PlaceholderValue : public ValueBase {
+  SILFunction *parentFunction;
   static int numPlaceholderValuesAlive;
 
 public:
-  PlaceholderValue(SILType type);
+  PlaceholderValue(SILFunction *parentFunction, SILType type);
   ~PlaceholderValue();
 
   static int getNumPlaceholderValuesAlive() { return numPlaceholderValuesAlive; }
 
+  SILFunction *getParent() const { return parentFunction; }
+
   static bool classof(const SILArgument *) = delete;
   static bool classof(const SILInstruction *) = delete;
   static bool classof(SILNodePointer node) {