Merge pull request swiftlang#23228 from slavapestov/type-lowering-is-trivial

Replace SILType::isTrivial(SILModule) with isTrivial(SILFunction)

Author: slavapestov

include/swift/AST/Types.h

@@ -3538,8 +3538,7 @@ class SILResultInfo {
   }
 
   ValueOwnershipKind
-  getOwnershipKind(SILModule &,
-                   CanGenericSignature sig) const; // in SILType.cpp
+  getOwnershipKind(SILFunction &) const; // in SILType.cpp
 
   bool operator==(SILResultInfo rhs) const {
     return TypeAndConvention == rhs.TypeAndConvention;

include/swift/SIL/OwnershipUtils.h

@@ -147,7 +147,7 @@ LinearLifetimeError valueHasLinearLifetime(
     SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
 
 /// Returns true if v is an address or trivial.
-bool isValueAddressOrTrivial(SILValue v, SILModule &m);
+bool isValueAddressOrTrivial(SILValue v);
 
 /// These operations forward both owned and guaranteed ownership.
 bool isOwnershipForwardingValueKind(SILNodeKind kind);

include/swift/SIL/Projection.h

@@ -602,7 +602,7 @@ class ProjectionPath {
 
   /// Return true if the given projection paths in \p CPaths does not cover
   /// all the fields with non-trivial semantics, false otherwise.
-  static bool hasUncoveredNonTrivials(SILType B, SILModule *Mod,
+  static bool hasUncoveredNonTrivials(SILType B, const SILFunction &F,
                                       ProjectionPathSet &CPaths);
 
   /// Returns true if the two paths have a non-empty symmetric

include/swift/SIL/SILBuilder.h

@@ -671,7 +671,7 @@ class SILBuilder {
       return createLoad(Loc, LV, LoadOwnershipQualifier::Unqualified);
     }
 
-    if (LV->getType().isTrivial(getModule())) {
+    if (LV->getType().isTrivial(getFunction())) {
       return createLoad(Loc, LV, LoadOwnershipQualifier::Trivial);
     }
     return createLoad(Loc, LV, Qualifier);
@@ -764,7 +764,7 @@ class SILBuilder {
       return createStore(Loc, Src, DestAddr,
                          StoreOwnershipQualifier::Unqualified);
     }
-    if (Src->getType().isTrivial(getModule())) {
+    if (Src->getType().isTrivial(getFunction())) {
       return createStore(Loc, Src, DestAddr, StoreOwnershipQualifier::Trivial);
     }
     return createStore(Loc, Src, DestAddr, Qualifier);
@@ -1095,7 +1095,7 @@ class SILBuilder {
   }
 
   CopyValueInst *createCopyValue(SILLocation Loc, SILValue operand) {
-    assert(!operand->getType().isTrivial(getModule()) &&
+    assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
            "emitCopyValueOperation");
     return insert(new (getModule())
@@ -1104,7 +1104,7 @@ class SILBuilder {
 
   DestroyValueInst *createDestroyValue(SILLocation Loc, SILValue operand) {
     assert(isLoadableOrOpaque(operand->getType()));
-    assert(!operand->getType().isTrivial(getModule()) &&
+    assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
            "emitDestroyValueOperation");
     return insert(new (getModule())
@@ -1398,13 +1398,13 @@ class SILBuilder {
   DestructureStructInst *createDestructureStruct(SILLocation Loc,
                                                  SILValue Operand) {
     return insert(DestructureStructInst::create(
-        getModule(), getSILDebugLocation(Loc), Operand));
+        getFunction(), getSILDebugLocation(Loc), Operand));
   }
 
   DestructureTupleInst *createDestructureTuple(SILLocation Loc,
                                                SILValue Operand) {
     return insert(DestructureTupleInst::create(
-        getModule(), getSILDebugLocation(Loc), Operand));
+        getFunction(), getSILDebugLocation(Loc), Operand));
   }
 
   MultipleValueInstruction *emitDestructureValueOperation(SILLocation loc,

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/SILInstruction.h

@@ -4700,14 +4700,14 @@ class StructInst final : public InstructionBaseWithTrailingOperands<
   /// Search the operands of this struct for a unique non-trivial field. If we
   /// find it, return it. Otherwise return SILValue().
   SILValue getUniqueNonTrivialFieldValue() {
-    SILModule &Mod = getModule();
+    auto *F = getFunction();
     ArrayRef<Operand> Ops = getAllOperands();
 
     Optional<unsigned> Index;
     // For each operand...
     for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
       // If the operand is not trivial...
-      if (!Ops[i].get()->getType().isTrivial(Mod)) {
+      if (!Ops[i].get()->getType().isTrivial(*F)) {
         // And we have not found an Index yet, set index to i and continue.
         if (!Index.hasValue()) {
           Index = i;
@@ -4993,14 +4993,14 @@ class TupleInst final : public InstructionBaseWithTrailingOperands<
   /// Search the operands of this tuple for a unique non-trivial elt. If we find
   /// it, return it. Otherwise return SILValue().
   SILValue getUniqueNonTrivialElt() {
-    SILModule &Mod = getModule();
+    auto *F = getFunction();
     ArrayRef<Operand> Ops = getAllOperands();
 
     Optional<unsigned> Index;
     // For each operand...
     for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
       // If the operand is not trivial...
-      if (!Ops[i].get()->getType().isTrivial(Mod)) {
+      if (!Ops[i].get()->getType().isTrivial(*F)) {
         // And we have not found an Index yet, set index to i and continue.
         if (!Index.hasValue()) {
           Index = i;
@@ -7724,7 +7724,8 @@ class DestructureStructInst final
         MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
 
 public:
-  static DestructureStructInst *create(SILModule &M, SILDebugLocation Loc,
+  static DestructureStructInst *create(const SILFunction &F,
+                                       SILDebugLocation Loc,
                                        SILValue Operand);
   static bool classof(const SILNode *N) {
     return N->getKind() == SILNodeKind::DestructureStructInst;
@@ -7772,7 +7773,8 @@ class DestructureTupleInst final
         MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
 
 public:
-  static DestructureTupleInst *create(SILModule &M, SILDebugLocation Loc,
+  static DestructureTupleInst *create(const SILFunction &F,
+                                      SILDebugLocation Loc,
                                       SILValue Operand);
   static bool classof(const SILNode *N) {
     return N->getKind() == SILNodeKind::DestructureTupleInst;

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/SILType.h

@@ -284,11 +284,8 @@ class SILType {
   /// \p F into account (see isLoadable(SILFunction)).
   bool isAddressOnly(const SILFunction &F) const;
 
-  /// True if the type, or the referenced type of an address type, is trivial.
-  bool isTrivial(SILModule &M) const;
-
-  /// Like isTrivial(SILModule), but takes the resilience expansion of
-  /// \p F into account (see isLoadable(SILFunction)).
+  /// True if the type, or the referenced type of an address type, is trivial,
+  /// meaning it is loadable and can be trivially copied, moved or detroyed.
   bool isTrivial(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is known to

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/SIL/SILValue.h

@@ -137,7 +137,7 @@ struct ValueOwnershipKind {
 
   ValueOwnershipKind(innerty NewValue) : Value(NewValue) {}
   explicit ValueOwnershipKind(unsigned NewValue) : Value(innerty(NewValue)) {}
-  ValueOwnershipKind(SILModule &M, SILType Type,
+  ValueOwnershipKind(const SILFunction &F, SILType Type,
                      SILArgumentConvention Convention);
 
   /// Parse Value into a ValueOwnershipKind.
@@ -157,7 +157,7 @@ struct ValueOwnershipKind {
   /// ownership kind, and a subobject of type Proj is being projected from the
   /// aggregate, return Trivial if Proj has trivial type and the aggregate's
   /// ownership kind otherwise.
-  ValueOwnershipKind getProjectedOwnershipKind(SILModule &M,
+  ValueOwnershipKind getProjectedOwnershipKind(const SILFunction &F,
                                                SILType Proj) const;
 
   /// Return the lifetime constraint semantics for this
@@ -374,8 +374,7 @@ class SILValue {
   ValueOwnershipKind getOwnershipKind() const;
 
   /// Verify that this SILValue and its uses respects ownership invariants.
-  void verifyOwnership(SILModule &Mod,
-                       DeadEndBlocks *DEBlocks = nullptr) const;
+  void verifyOwnership(DeadEndBlocks *DEBlocks = nullptr) const;
 };
 
 /// A map from a ValueOwnershipKind that an operand can accept to a