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

For years, optimizer engineers have been hitting a common bug caused by passes
assuming all SILValues have a parent function only to be surprised by SILUndef.
Generally we see SILUndef not that often so we see this come up later in
testing. This patch eliminates that problem by making SILUndef uniqued at the
function level instead of the module level. This ensures that it makes sense for
SILUndef to have a parent function, eliminating this possibility since we can
define an API to get its parent function.

rdar://123484595

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,9 @@ class SILFunction
 
   PerformanceConstraints perfConstraints = PerformanceConstraints::None;
 
+  /// This is the set of undef values we've created, for uniquing purposes.
+  llvm::DenseMap<SILType, SILUndef *> undefValues;
+
   /// This is the number of uses of this SILFunction inside the SIL.
   /// It does not include references from debug scopes.
   unsigned RefCount = 0;

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/SILOptimizer/OptimizerBridging.h

@@ -307,7 +307,9 @@ struct BridgedPassContext {
 
   // SSAUpdater
 
-  BRIDGED_INLINE void SSAUpdater_initialize(BridgedType type, BridgedValue::Ownership ownership) const;
+  BRIDGED_INLINE void
+  SSAUpdater_initialize(BridgedFunction function, BridgedType type,
+                        BridgedValue::Ownership ownership) const;
   BRIDGED_INLINE void SSAUpdater_addAvailableValue(BridgedBasicBlock block, BridgedValue value) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedValue SSAUpdater_getValueAtEndOfBlock(BridgedBasicBlock block) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedValue SSAUpdater_getValueInMiddleOfBlock(BridgedBasicBlock block) const;