SIL: SILUndef must be aware of the resilience expansion

The ownership kind is Any for trivial types, or Owned otherwise, but
whether a type is trivial or not will soon depend on the resilience
expansion.

This means that a SILModule now uniques two SILUndefs per type instead
of one, and serialization uses two distinct sentinel IDs for this
purpose as well.

For now, the resilience expansion is not actually used here, so this
change is NFC, other than changing the module format.

Author: slavapestov

include/swift/SIL/SILCloner.h

@@ -526,7 +526,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.getModule()));
+      (type == U->getType() ? U : SILUndef::get(type, Builder.getFunction()));
     return SILValue(undef);
   }
 

include/swift/SIL/SILModule.h

@@ -221,7 +221,7 @@ class SILModule {
   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<SILType, unsigned>, SILUndef *> UndefValues;
 
   /// The stage of processing this module is at.
   SILStage Stage;

include/swift/SIL/SILUndef.h

@@ -25,18 +25,20 @@ class SILModule;
 class SILUndef : public ValueBase {
   ValueOwnershipKind ownershipKind;
 
-  SILUndef(SILType type, SILModule &m);
+  SILUndef(SILType type, ValueOwnershipKind ownershipKind);
 
 public:
   void operator=(const SILArgument &) = delete;
   void operator delete(void *, size_t) SWIFT_DELETE_OPERATOR_DELETED;
 
-  static SILUndef *get(SILType ty, SILModule &m);
-  static SILUndef *get(SILType ty, SILModule *m) { return get(ty, *m); }
+  static SILUndef *get(SILType ty, SILModule &m, ValueOwnershipKind ownershipKind);
+  static SILUndef *get(SILType ty, const SILFunction &f);
 
   template <class OwnerTy>
-  static SILUndef *getSentinelValue(SILType type, SILModule &m, OwnerTy owner) {
-    return new (*owner) SILUndef(type, m);
+  static SILUndef *getSentinelValue(SILType type, OwnerTy owner) {
+    // Ownership kind isn't used here, the value just needs to have a unique
+    // address.
+    return new (*owner) SILUndef(type, ValueOwnershipKind::Any);
   }
 
   ValueOwnershipKind getOwnershipKind() const { return ownershipKind; }

include/swift/SILOptimizer/Utils/SILSSAUpdater.h

@@ -51,15 +51,12 @@ class SILSSAUpdater {
   // If not null updated with inserted 'phi' nodes (SILArgument).
   SmallVectorImpl<SILPhiArgument *> *InsertedPHIs;
 
-  SILModule &M;
-
   // Not copyable.
   void operator=(const SILSSAUpdater &) = delete;
   SILSSAUpdater(const SILSSAUpdater &) = delete;
 
 public:
   explicit SILSSAUpdater(
-      SILModule &M,
       SmallVectorImpl<SILPhiArgument *> *InsertedPHIs = nullptr);
   ~SILSSAUpdater();
 

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 476; // Last change: prebuilt module cache
+const uint16_t SWIFTMODULE_VERSION_MINOR = 477; // SILUndef serialized with ownership kind
 
 using DeclIDField = BCFixed<31>;
 

lib/IRGen/LoadableByAddress.cpp

@@ -1317,7 +1317,7 @@ void LoadableStorageAllocation::allocateLoadableStorage() {
 SILArgument *LoadableStorageAllocation::replaceArgType(SILBuilder &argBuilder,
                                                        SILArgument *arg,
                                                        SILType newSILType) {
-  SILValue undef = SILUndef::get(newSILType, pass.F->getModule());
+  SILValue undef = SILUndef::get(newSILType, *pass.F);
   SmallVector<Operand *, 8> useList(arg->use_begin(), arg->use_end());
   for (auto *use : useList) {
     use->set(undef);
@@ -1387,7 +1387,7 @@ void LoadableStorageAllocation::convertIndirectFunctionArgs() {
 
 static void convertBBArgType(SILBuilder &argBuilder, SILType newSILType,
                              SILArgument *arg) {
-  SILValue undef = SILUndef::get(newSILType, argBuilder.getModule());
+  SILValue undef = SILUndef::get(newSILType, argBuilder.getFunction());
   SmallVector<Operand *, 8> useList(arg->use_begin(), arg->use_end());
   for (auto *use : useList) {
     use->set(undef);

lib/ParseSIL/ParseSIL.cpp

@@ -738,7 +738,7 @@ bool SILParser::parseGlobalName(Identifier &Name) {
 SILValue SILParser::getLocalValue(UnresolvedValueName Name, SILType Type,
                                   SILLocation Loc, SILBuilder &B) {
   if (Name.isUndef())
-    return SILUndef::get(Type, &SILMod);
+    return SILUndef::get(Type, B.getFunction());
 
   // Check to see if this is already defined.
   ValueBase *&Entry = LocalValues[Name.Name];

lib/SIL/Projection.cpp

@@ -1153,7 +1153,7 @@ ProjectionTree::computeExplodedArgumentValueInner(SILBuilder &Builder,
     if (Iter != LeafValues.end())
       return Iter->second;
     // Return undef for dead node.
-    return SILUndef::get(Node->getType(), Mod);
+    return SILUndef::get(Node->getType(), Builder.getFunction());
   }
 
   // This is an aggregate node, construct its value from its children

lib/SIL/SILUndef.cpp

@@ -15,20 +15,24 @@
 
 using namespace swift;
 
-static ValueOwnershipKind getOwnershipKindForUndef(SILType type, SILModule &m) {
-  if (type.isTrivial(m))
+static ValueOwnershipKind getOwnershipKindForUndef(SILType type, const SILFunction &f) {
+  if (type.isTrivial(f))
     return ValueOwnershipKind::Any;
   return ValueOwnershipKind::Owned;
 }
 
-SILUndef::SILUndef(SILType type, SILModule &m)
+SILUndef::SILUndef(SILType type, ValueOwnershipKind ownershipKind)
     : ValueBase(ValueKind::SILUndef, type, IsRepresentative::Yes),
-      ownershipKind(getOwnershipKindForUndef(type, m)) {}
+      ownershipKind(ownershipKind) {}
 
-SILUndef *SILUndef::get(SILType ty, SILModule &m) {
-  // Unique these.
-  SILUndef *&entry = m.UndefValues[ty];
+SILUndef *SILUndef::get(SILType ty, SILModule &m, ValueOwnershipKind ownershipKind) {
+  SILUndef *&entry = m.UndefValues[std::make_pair(ty, unsigned(ownershipKind))];
   if (entry == nullptr)
-    entry = new (m) SILUndef(ty, m);
+    entry = new (m) SILUndef(ty, ownershipKind);
   return entry;
 }
+
+SILUndef *SILUndef::get(SILType ty, const SILFunction &f) {
+  auto ownershipKind = getOwnershipKindForUndef(ty, f);
+  return SILUndef::get(ty, f.getModule(), ownershipKind);
+}

lib/SIL/SILValue.cpp

@@ -53,14 +53,14 @@ void ValueBase::replaceAllUsesWith(ValueBase *RHS) {
 }
 
 void ValueBase::replaceAllUsesWithUndef() {
-  SILModule *Mod = getModule();
-  if (!Mod) {
+  auto *F = getFunction();
+  if (!F) {
     llvm_unreachable("replaceAllUsesWithUndef can only be used on ValueBase "
-                     "that have access to the parent module.");
+                     "that have access to the parent function.");
   }
   while (!use_empty()) {
     Operand *Op = *use_begin();
-    Op->set(SILUndef::get(Op->get()->getType(), Mod));
+    Op->set(SILUndef::get(Op->get()->getType(), *F));
   }
 }