Merge pull request #6724 from gottesmm/silargument_ownershipkind

SILArguments now must always have ValueOwnershipKind

Author: gottesmm

include/swift/SIL/SILArgument.h

@@ -40,8 +40,12 @@ class SILArgument : public ValueBase {
 
   SILBasicBlock *ParentBB;
   const ValueDecl *Decl;
+  ValueOwnershipKind OwnershipKind;
 
 public:
+  ValueOwnershipKind getOwnershipKind() const { return OwnershipKind; }
+  void setOwnershipKind(ValueOwnershipKind NewKind) { OwnershipKind = NewKind; }
+
   SILBasicBlock *getParent() { return ParentBB; }
   const SILBasicBlock *getParent() const { return ParentBB; }
 
@@ -103,28 +107,26 @@ class SILArgument : public ValueBase {
 
 protected:
   SILArgument(ValueKind SubClassKind, SILBasicBlock *ParentBB, SILType Ty,
+              ValueOwnershipKind OwnershipKind,
               const ValueDecl *D = nullptr);
   SILArgument(ValueKind SubClassKind, SILBasicBlock *ParentBB,
               SILBasicBlock::arg_iterator Pos, SILType Ty,
+              ValueOwnershipKind OwnershipKind,
               const ValueDecl *D = nullptr);
 
   // A special constructor, only intended for use in
-  // SILBasicBlock::replaceBBArg.
+  // SILBasicBlock::replacePHIArg.
   explicit SILArgument(ValueKind SubClassKind, SILType Ty,
+                       ValueOwnershipKind OwnershipKind,
                        const ValueDecl *D = nullptr)
-      : ValueBase(SubClassKind, Ty), ParentBB(nullptr), Decl(D) {}
+      : ValueBase(SubClassKind, Ty), ParentBB(nullptr), Decl(D), OwnershipKind(OwnershipKind) {}
   void setParent(SILBasicBlock *P) { ParentBB = P; }
 
   friend SILBasicBlock;
 };
 
 class SILPHIArgument : public SILArgument {
-  ValueOwnershipKind Kind;
-
 public:
-  /// Return the static ownership kind associated with this SILPHIArgument.
-  ValueOwnershipKind getOwnershipKind() const { return Kind; }
-
   /// Returns the incoming SILValue from the \p BBIndex predecessor of this
   /// argument's parent BB. If the routine fails, it returns an empty SILValue.
   /// Note that for some predecessor terminators the incoming value is not
@@ -167,20 +169,19 @@ class SILPHIArgument : public SILArgument {
 
 private:
   friend SILBasicBlock;
-  SILPHIArgument(SILBasicBlock *ParentBB, SILType Ty, ValueOwnershipKind Kind,
+  SILPHIArgument(SILBasicBlock *ParentBB, SILType Ty, ValueOwnershipKind OwnershipKind,
                  const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILPHIArgument, ParentBB, Ty, D), Kind(Kind) {}
+      : SILArgument(ValueKind::SILPHIArgument, ParentBB, Ty, OwnershipKind, D) {}
   SILPHIArgument(SILBasicBlock *ParentBB, SILBasicBlock::arg_iterator Pos,
-                 SILType Ty, ValueOwnershipKind Kind,
+                 SILType Ty, ValueOwnershipKind OwnershipKind,
                  const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILPHIArgument, ParentBB, Pos, Ty, D),
-        Kind(Kind) {}
+      : SILArgument(ValueKind::SILPHIArgument, ParentBB, Pos, Ty, OwnershipKind, D) {}
 
   // A special constructor, only intended for use in
-  // SILBasicBlock::replaceBBArg.
-  explicit SILPHIArgument(SILType Ty, ValueOwnershipKind Kind,
+  // SILBasicBlock::replacePHIArg.
+  explicit SILPHIArgument(SILType Ty, ValueOwnershipKind OwnershipKind,
                           const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILPHIArgument, Ty, D), Kind(Kind) {}
+      : SILArgument(ValueKind::SILPHIArgument, Ty, OwnershipKind, D) {}
 };
 
 class SILFunctionArgument : public SILArgument {
@@ -226,16 +227,12 @@ class SILFunctionArgument : public SILArgument {
 private:
   friend SILBasicBlock;
 
-  SILFunctionArgument(SILBasicBlock *ParentBB, SILType Ty,
+  SILFunctionArgument(SILBasicBlock *ParentBB, SILType Ty, ValueOwnershipKind OwnershipKind,
                       const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILFunctionArgument, ParentBB, Ty, D) {}
+      : SILArgument(ValueKind::SILFunctionArgument, ParentBB, Ty, OwnershipKind, D) {}
   SILFunctionArgument(SILBasicBlock *ParentBB, SILBasicBlock::arg_iterator Pos,
-                      SILType Ty, const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILFunctionArgument, ParentBB, Pos, Ty, D) {}
-
-  // A special constructor, only intended for use in SILBasicBlock::replaceBBArg.
-  explicit SILFunctionArgument(SILType Ty, const ValueDecl *D = nullptr)
-      : SILArgument(ValueKind::SILFunctionArgument, Ty, D) {}
+                      SILType Ty, ValueOwnershipKind OwnershipKind, const ValueDecl *D = nullptr)
+      : SILArgument(ValueKind::SILFunctionArgument, ParentBB, Pos, Ty, OwnershipKind, D) {}
 };
 
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILBasicBlock.h

@@ -180,38 +180,34 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
                                               const ValueDecl *D = nullptr);
 
   SILFunctionArgument *insertFunctionArgument(unsigned Index, SILType Ty,
+                                              ValueOwnershipKind OwnershipKind,
                                               const ValueDecl *D = nullptr) {
     arg_iterator Pos = ArgumentList.begin();
     std::advance(Pos, Index);
-    return insertFunctionArgument(Pos, Ty, D);
+    return insertFunctionArgument(Pos, Ty, OwnershipKind, D);
   }
 
   /// Replace the \p{i}th BB arg with a new BBArg with SILType \p Ty and
   /// ValueDecl
   /// \p D.
-  SILPHIArgument *
-  replacePHIArgument(unsigned i, SILType Ty,
-                     ValueOwnershipKind Kind = ValueOwnershipKind::Any,
-                     const ValueDecl *D = nullptr);
+  SILPHIArgument *replacePHIArgument(unsigned i, SILType Ty,
+                                     ValueOwnershipKind Kind,
+                                     const ValueDecl *D = nullptr);
 
   /// Allocate a new argument of type \p Ty and append it to the argument
   /// list. Optionally you can pass in a value decl parameter.
-  SILPHIArgument *
-  createPHIArgument(SILType Ty,
-                    ValueOwnershipKind Kind = ValueOwnershipKind::Any,
-                    const ValueDecl *D = nullptr);
+  SILPHIArgument *createPHIArgument(SILType Ty, ValueOwnershipKind Kind,
+                                    const ValueDecl *D = nullptr);
 
   /// Insert a new SILPHIArgument with type \p Ty and \p Decl at position \p
   /// Pos.
-  SILPHIArgument *
-  insertPHIArgument(arg_iterator Pos, SILType Ty,
-                    ValueOwnershipKind Kind = ValueOwnershipKind::Any,
-                    const ValueDecl *D = nullptr);
-
-  SILPHIArgument *
-  insertPHIArgument(unsigned Index, SILType Ty,
-                    ValueOwnershipKind Kind = ValueOwnershipKind::Any,
-                    const ValueDecl *D = nullptr) {
+  SILPHIArgument *insertPHIArgument(arg_iterator Pos, SILType Ty,
+                                    ValueOwnershipKind Kind,
+                                    const ValueDecl *D = nullptr);
+
+  SILPHIArgument *insertPHIArgument(unsigned Index, SILType Ty,
+                                    ValueOwnershipKind Kind,
+                                    const ValueDecl *D = nullptr) {
     arg_iterator Pos = ArgumentList.begin();
     std::advance(Pos, Index);
     return insertPHIArgument(Pos, Ty, Kind, D);
@@ -345,6 +341,7 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
   /// Insert a new SILFunctionArgument with type \p Ty and \p Decl at position
   /// \p Pos.
   SILFunctionArgument *insertFunctionArgument(arg_iterator Pos, SILType Ty,
+                                              ValueOwnershipKind OwnershipKind,
                                               const ValueDecl *D = nullptr);
 };
 

include/swift/SIL/SILType.h

@@ -67,7 +67,7 @@ enum class ExistentialRepresentation {
 };
 
 /// The value category.
-enum class SILValueCategory {
+enum class SILValueCategory : uint8_t {
   /// An object is a value of the type.
   Object,
 

include/swift/SIL/SILValue.h

@@ -107,6 +107,7 @@ struct ValueOwnershipKind {
   } Value;
 
   ValueOwnershipKind(innerty NewValue) : Value(NewValue) {}
+  ValueOwnershipKind(unsigned NewValue) : Value(innerty(NewValue)) {}
   ValueOwnershipKind(SILModule &M, SILType Type,
                      SILArgumentConvention Convention);
 

include/swift/SILOptimizer/Utils/FunctionSignatureOptUtils.h

@@ -125,6 +125,17 @@ struct ArgumentDescriptor {
     size_t explosionSize = ProjTree.liveLeafCount();
     return explosionSize >= 1 && explosionSize <= 3;
   }
+
+  llvm::Optional<ValueOwnershipKind>
+  getTransformedOwnershipKind(SILType SubTy) {
+    if (IsEntirelyDead)
+      return None;
+    if (SubTy.isTrivial(Arg->getModule()))
+      return Optional<ValueOwnershipKind>(ValueOwnershipKind::Trivial);
+    if (OwnedToGuaranteed)
+      return Optional<ValueOwnershipKind>(ValueOwnershipKind::Guaranteed);
+    return Arg->getOwnershipKind();
+  }
 };
 
 /// A structure that maintains all of the information about a specific

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// 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.
-const uint16_t VERSION_MINOR = 305; // Last change: linkage in SILVTable::Entry
+const uint16_t VERSION_MINOR = 306; // Last change: SILArgument+Ownership
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/Parse/ParseSIL.cpp

@@ -3963,7 +3963,7 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
         if (IsEntry)
           Arg = BB->createFunctionArgument(Ty);
         else
-          Arg = BB->createPHIArgument(Ty);
+          Arg = BB->createPHIArgument(Ty, ValueOwnershipKind::Any);
         setLocalValue(Arg, Name, NameLoc);
       } while (P.consumeIf(tok::comma));
 

lib/SIL/DynamicCasts.cpp

@@ -929,8 +929,9 @@ namespace {
           objectSource = Source(sourceAddr, sourceObjectType,
                                 CastConsumptionKind::TakeAlways);
         } else {
-          SILValue sourceObjectValue =
-              someBB->createPHIArgument(loweredSourceObjectType);
+          // switch enum always start as @owned.
+          SILValue sourceObjectValue = someBB->createPHIArgument(
+              loweredSourceObjectType, ValueOwnershipKind::Owned);
           objectSource = Source(sourceObjectValue, sourceObjectType,
                                 source.Consumption);
         }
@@ -968,7 +969,8 @@ namespace {
       if (target.isAddress()) {
         return target.asAddressSource();
       } else {
-        SILValue result = contBB->createPHIArgument(target.LoweredType);
+        SILValue result = contBB->createPHIArgument(target.LoweredType,
+                                                    ValueOwnershipKind::Owned);
         return target.asScalarSource(result);
       }
     }
@@ -1214,7 +1216,8 @@ emitIndirectConditionalCastWithScalar(SILBuilder &B, ModuleDecl *M,
   // Emit the success block.
   B.setInsertionPoint(scalarSuccBB); {
     auto &targetTL = B.getModule().Types.getTypeLowering(targetValueType);
-    SILValue succValue = scalarSuccBB->createPHIArgument(targetValueType);
+    SILValue succValue = scalarSuccBB->createPHIArgument(
+        targetValueType, ValueOwnershipKind::Owned);
     if (!shouldTakeOnSuccess(consumption))
       targetTL.emitCopyValue(B, loc, succValue);
     targetTL.emitStoreOfCopy(B, loc, succValue, dest, IsInitialization);

lib/SIL/SILArgument.cpp

@@ -24,15 +24,18 @@ using namespace swift;
 //===----------------------------------------------------------------------===//
 
 SILArgument::SILArgument(ValueKind ChildKind, SILBasicBlock *ParentBB,
-                         SILType Ty, const ValueDecl *D)
-    : ValueBase(ChildKind, Ty), ParentBB(ParentBB), Decl(D) {
+                         SILType Ty, ValueOwnershipKind OwnershipKind,
+                         const ValueDecl *D)
+    : ValueBase(ChildKind, Ty), ParentBB(ParentBB), Decl(D),
+      OwnershipKind(OwnershipKind) {
   ParentBB->insertArgument(ParentBB->args_end(), this);
 }
 
 SILArgument::SILArgument(ValueKind ChildKind, SILBasicBlock *ParentBB,
                          SILBasicBlock::arg_iterator Pos, SILType Ty,
+                         ValueOwnershipKind OwnershipKind,
                          const ValueDecl *D)
-    : ValueBase(ChildKind, Ty), ParentBB(ParentBB), Decl(D) {
+    : ValueBase(ChildKind, Ty), ParentBB(ParentBB), Decl(D), OwnershipKind(OwnershipKind) {
   // Function arguments need to have a decl.
   assert(
     !ParentBB->getParent()->isBare() &&

lib/SIL/SILBasicBlock.cpp

@@ -107,8 +107,10 @@ void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {
   assert(Other->isEntry() == isEntry() &&
          "Expected to both blocks to be entries or not");
   if (isEntry()) {
+    assert(args_empty() && "Expected to have no arguments");
     for (auto *FuncArg : Other->getFunctionArguments()) {
-      createFunctionArgument(FuncArg->getType(), FuncArg->getDecl());
+      createFunctionArgument(FuncArg->getType(),
+                             FuncArg->getDecl());
     }
     return;
   }
@@ -122,14 +124,20 @@ void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {
 SILFunctionArgument *SILBasicBlock::createFunctionArgument(SILType Ty,
                                                            const ValueDecl *D) {
   assert(isEntry() && "Function Arguments can only be in the entry block");
-  return new (getModule()) SILFunctionArgument(this, Ty, D);
+  SILFunction *Parent = getParent();
+  auto OwnershipKind = ValueOwnershipKind(
+      Parent->getModule(), Ty,
+      Parent->getLoweredFunctionType()->getSILArgumentConvention(
+          getNumArguments()));
+  return new (getModule()) SILFunctionArgument(this, Ty, OwnershipKind, D);
 }
 
 SILFunctionArgument *SILBasicBlock::insertFunctionArgument(arg_iterator Iter,
                                                            SILType Ty,
+                                                           ValueOwnershipKind OwnershipKind,
                                                            const ValueDecl *D) {
   assert(isEntry() && "Function Arguments can only be in the entry block");
-  return new (getModule()) SILFunctionArgument(this, Iter, Ty, D);
+  return new (getModule()) SILFunctionArgument(this, Iter, Ty, OwnershipKind, D);
 }
 
 /// Replace the ith BB argument with a new one with type Ty (and optional
@@ -139,6 +147,8 @@ SILPHIArgument *SILBasicBlock::replacePHIArgument(unsigned i, SILType Ty,
                                                   const ValueDecl *D) {
   assert(!isEntry() && "PHI Arguments can not be in the entry block");
   SILModule &M = getParent()->getModule();
+  if (Ty.isTrivial(M))
+    Kind = ValueOwnershipKind::Trivial;
 
   assert(ArgumentList[i]->use_empty() && "Expected no uses of the old BB arg!");
 
@@ -159,13 +169,21 @@ SILPHIArgument *SILBasicBlock::createPHIArgument(SILType Ty,
                                                  ValueOwnershipKind Kind,
                                                  const ValueDecl *D) {
   assert(!isEntry() && "PHI Arguments can not be in the entry block");
+  assert(!getParent()->hasQualifiedOwnership() ||
+         Kind != ValueOwnershipKind::Any);
+  if (Ty.isTrivial(getModule()))
+    Kind = ValueOwnershipKind::Trivial;
   return new (getModule()) SILPHIArgument(this, Ty, Kind, D);
 }
 
 SILPHIArgument *SILBasicBlock::insertPHIArgument(arg_iterator Iter, SILType Ty,
                                                  ValueOwnershipKind Kind,
                                                  const ValueDecl *D) {
   assert(!isEntry() && "PHI Arguments can not be in the entry block");
+  assert(!getParent()->hasQualifiedOwnership() ||
+         Kind != ValueOwnershipKind::Any);
+  if (Ty.isTrivial(getModule()))
+    Kind = ValueOwnershipKind::Trivial;
   return new (getModule()) SILPHIArgument(this, Iter, Ty, Kind, D);
 }