Merge pull request swiftlang#20062 from gottesmm/pr-8d1e1d25d9d909af8231dfb8cfe502e0fef3043d

Author: swift-ci

include/swift/SIL/SILBuilder.h

@@ -145,19 +145,19 @@ class SILBuilder {
 public:
   explicit SILBuilder(SILFunction &F, bool isParsing = false)
       : TempContext(F.getModule()), C(TempContext), F(&F),
-        hasOwnership(F.hasQualifiedOwnership()), BB(0) {
+        hasOwnership(F.hasOwnership()), BB(0) {
     C.isParsing = isParsing;
   }
 
   SILBuilder(SILFunction &F, SmallVectorImpl<SILInstruction *> *InsertedInstrs)
       : TempContext(F.getModule(), InsertedInstrs), C(TempContext), F(&F),
-        hasOwnership(F.hasQualifiedOwnership()), BB(0) {}
+        hasOwnership(F.hasOwnership()), BB(0) {}
 
   explicit SILBuilder(SILInstruction *I,
                       SmallVectorImpl<SILInstruction *> *InsertedInstrs = 0)
       : TempContext(I->getFunction()->getModule(), InsertedInstrs),
         C(TempContext), F(I->getFunction()),
-        hasOwnership(F->hasQualifiedOwnership()) {
+        hasOwnership(F->hasOwnership()) {
     setInsertionPoint(I);
   }
 
@@ -169,7 +169,7 @@ class SILBuilder {
                       SmallVectorImpl<SILInstruction *> *InsertedInstrs = 0)
       : TempContext(BB->getParent()->getModule(), InsertedInstrs),
         C(TempContext), F(BB->getParent()),
-        hasOwnership(F->hasQualifiedOwnership()) {
+        hasOwnership(F->hasOwnership()) {
     setInsertionPoint(BB);
   }
 
@@ -180,7 +180,7 @@ class SILBuilder {
              SmallVectorImpl<SILInstruction *> *InsertedInstrs = 0)
       : TempContext(BB->getParent()->getModule(), InsertedInstrs),
         C(TempContext), F(BB->getParent()),
-        hasOwnership(F->hasQualifiedOwnership()) {
+        hasOwnership(F->hasOwnership()) {
     setInsertionPoint(BB, InsertPt);
   }
 
@@ -190,7 +190,7 @@ class SILBuilder {
   /// SILBuilderContext must outlive this SILBuilder instance.
   SILBuilder(SILInstruction *I, const SILDebugScope *DS, SILBuilderContext &C)
       : TempContext(C.getModule()), C(C), F(I->getFunction()),
-        hasOwnership(F->hasQualifiedOwnership()) {
+        hasOwnership(F->hasOwnership()) {
     assert(DS && "instruction has no debug scope");
     setCurrentDebugScope(DS);
     setInsertionPoint(I);
@@ -202,7 +202,7 @@ class SILBuilder {
   /// SILBuilderContext must outlive this SILBuilder instance.
   SILBuilder(SILBasicBlock *BB, const SILDebugScope *DS, SILBuilderContext &C)
       : TempContext(C.getModule()), C(C), F(BB->getParent()),
-        hasOwnership(F->hasQualifiedOwnership()) {
+        hasOwnership(F->hasOwnership()) {
     assert(DS && "block has no debug scope");
     setCurrentDebugScope(DS);
     setInsertionPoint(BB);
@@ -683,7 +683,7 @@ class SILBuilder {
   LoadInst *createTrivialLoadOr(SILLocation Loc, SILValue LV,
                                 LoadOwnershipQualifier Qualifier,
                                 bool SupportUnqualifiedSIL = false) {
-    if (SupportUnqualifiedSIL && !getFunction().hasQualifiedOwnership()) {
+    if (SupportUnqualifiedSIL && !getFunction().hasOwnership()) {
       assert(
           Qualifier != LoadOwnershipQualifier::Copy &&
           "In unqualified SIL, a copy must be done separately form the load");
@@ -699,10 +699,10 @@ class SILBuilder {
   LoadInst *createLoad(SILLocation Loc, SILValue LV,
                        LoadOwnershipQualifier Qualifier) {
     assert((Qualifier != LoadOwnershipQualifier::Unqualified) ||
-           !getFunction().hasQualifiedOwnership() &&
+           !getFunction().hasOwnership() &&
                "Unqualified inst in qualified function");
     assert((Qualifier == LoadOwnershipQualifier::Unqualified) ||
-           getFunction().hasQualifiedOwnership() &&
+           getFunction().hasOwnership() &&
                "Qualified inst in unqualified function");
     assert(LV->getType().isLoadableOrOpaque(getModule()));
     return insert(new (getModule())
@@ -757,7 +757,7 @@ class SILBuilder {
                                   SILValue DestAddr,
                                   StoreOwnershipQualifier Qualifier,
                                   bool SupportUnqualifiedSIL = false) {
-    if (SupportUnqualifiedSIL && !getFunction().hasQualifiedOwnership()) {
+    if (SupportUnqualifiedSIL && !getFunction().hasOwnership()) {
       assert(
           Qualifier != StoreOwnershipQualifier::Assign &&
           "In unqualified SIL, assigns must be represented via 2 instructions");
@@ -773,10 +773,10 @@ class SILBuilder {
   StoreInst *createStore(SILLocation Loc, SILValue Src, SILValue DestAddr,
                          StoreOwnershipQualifier Qualifier) {
     assert((Qualifier != StoreOwnershipQualifier::Unqualified) ||
-           !getFunction().hasQualifiedOwnership() &&
+           !getFunction().hasOwnership() &&
                "Unqualified inst in qualified function");
     assert((Qualifier == StoreOwnershipQualifier::Unqualified) ||
-           getFunction().hasQualifiedOwnership() &&
+           getFunction().hasOwnership() &&
                "Qualified inst in unqualified function");
     return insert(new (getModule()) StoreInst(getSILDebugLocation(Loc), Src,
                                                 DestAddr, Qualifier));
@@ -1128,22 +1128,22 @@ class SILBuilder {
 
   RetainValueInst *createRetainValue(SILLocation Loc, SILValue operand,
                                      Atomicity atomicity) {
-    assert(C.isParsing || !getFunction().hasQualifiedOwnership());
+    assert(C.isParsing || !getFunction().hasOwnership());
     assert(operand->getType().isLoadableOrOpaque(getModule()));
     return insert(new (getModule()) RetainValueInst(getSILDebugLocation(Loc),
                                                       operand, atomicity));
   }
 
   RetainValueAddrInst *createRetainValueAddr(SILLocation Loc, SILValue operand,
                                              Atomicity atomicity) {
-    assert(C.isParsing || !getFunction().hasQualifiedOwnership());
+    assert(C.isParsing || !getFunction().hasOwnership());
     return insert(new (getModule()) RetainValueAddrInst(
         getSILDebugLocation(Loc), operand, atomicity));
   }
 
   ReleaseValueInst *createReleaseValue(SILLocation Loc, SILValue operand,
                                        Atomicity atomicity) {
-    assert(C.isParsing || !getFunction().hasQualifiedOwnership());
+    assert(C.isParsing || !getFunction().hasOwnership());
     assert(operand->getType().isLoadableOrOpaque(getModule()));
     return insert(new (getModule()) ReleaseValueInst(getSILDebugLocation(Loc),
                                                        operand, atomicity));
@@ -1152,15 +1152,15 @@ class SILBuilder {
   ReleaseValueAddrInst *createReleaseValueAddr(SILLocation Loc,
                                                SILValue operand,
                                                Atomicity atomicity) {
-    assert(C.isParsing || !getFunction().hasQualifiedOwnership());
+    assert(C.isParsing || !getFunction().hasOwnership());
     return insert(new (getModule()) ReleaseValueAddrInst(
         getSILDebugLocation(Loc), operand, atomicity));
   }
 
   UnmanagedRetainValueInst *createUnmanagedRetainValue(SILLocation Loc,
                                                        SILValue operand,
                                                        Atomicity atomicity) {
-    assert(getFunction().hasQualifiedOwnership());
+    assert(getFunction().hasOwnership());
     assert(operand->getType().isLoadableOrOpaque(getModule()));
     return insert(new (getModule()) UnmanagedRetainValueInst(
         getSILDebugLocation(Loc), operand, atomicity));
@@ -1169,7 +1169,7 @@ class SILBuilder {
   UnmanagedReleaseValueInst *createUnmanagedReleaseValue(SILLocation Loc,
                                                          SILValue operand,
                                                          Atomicity atomicity) {
-    assert(getFunction().hasQualifiedOwnership());
+    assert(getFunction().hasOwnership());
     assert(operand->getType().isLoadableOrOpaque(getModule()));
     return insert(new (getModule()) UnmanagedReleaseValueInst(
         getSILDebugLocation(Loc), operand, atomicity));
@@ -1637,13 +1637,13 @@ class SILBuilder {
 
   StrongRetainInst *createStrongRetain(SILLocation Loc, SILValue Operand,
                                        Atomicity atomicity) {
-    assert(C.isParsing || !getFunction().hasQualifiedOwnership());
+    assert(C.isParsing || !getFunction().hasOwnership());
     return insert(new (getModule()) StrongRetainInst(getSILDebugLocation(Loc),
                                                        Operand, atomicity));
   }
   StrongReleaseInst *createStrongRelease(SILLocation Loc, SILValue Operand,
                                          Atomicity atomicity) {
-    assert(C.isParsing || !getFunction().hasQualifiedOwnership());
+    assert(C.isParsing || !getFunction().hasOwnership());
     return insert(new (getModule()) StrongReleaseInst(
         getSILDebugLocation(Loc), Operand, atomicity));
   }
@@ -2080,7 +2080,7 @@ class SILBuilder {
   /// lowering for the non-address value.
   void emitDestroyValueOperation(SILLocation Loc, SILValue v) {
     assert(!v->getType().isAddress());
-    if (F->hasQualifiedOwnership() &&
+    if (F->hasOwnership() &&
         v.getOwnershipKind() == ValueOwnershipKind::Any)
       return;
     auto &lowering = getTypeLowering(v->getType());

include/swift/SIL/SILFunction.h

@@ -232,12 +232,13 @@ class SILFunction
   /// *) It is a function referenced by the specialization information.
   bool Zombie = false;
 
-  /// True if SILOwnership is enabled for this function.
+  /// True if this function is in Ownership SSA form and thus must pass
+  /// ownership verification.
   ///
   /// This enables the verifier to easily prove that before the Ownership Model
   /// Eliminator runs on a function, we only see a non-semantic-arc world and
   /// after the pass runs, we only see a semantic-arc world.
-  bool HasQualifiedOwnership = true;
+  bool HasOwnership = true;
 
   /// Set if the function body was deserialized from canonical SIL. This implies
   /// that the function's home module performed SIL diagnostics prior to
@@ -423,12 +424,12 @@ class SILFunction
   bool isZombie() const { return Zombie; }
 
   /// Returns true if this function has qualified ownership instructions in it.
-  bool hasQualifiedOwnership() const { return HasQualifiedOwnership; }
+  bool hasOwnership() const { return HasOwnership; }
 
-  /// Sets the HasQualifiedOwnership flag to false. This signals to SIL that no
+  /// Sets the HasOwnership flag to false. This signals to SIL that no
   /// ownership instructions should be in this function any more.
-  void setUnqualifiedOwnership() {
-    HasQualifiedOwnership = false;
+  void setOwnershipEliminated() {
+    HasOwnership = false;
   }
 
   /// Returns true if this function was deserialized from canonical

lib/IRGen/LoadableByAddress.cpp

@@ -1037,7 +1037,7 @@ static AllocStackInst *allocate(StructLoweringState &pass,
 
 static StoreOwnershipQualifier
 getStoreInitOwnership(StructLoweringState &pass, SILType type) {
-  if (!pass.F->hasQualifiedOwnership()) {
+  if (!pass.F->hasOwnership()) {
     return StoreOwnershipQualifier::Unqualified;
   } else if (type.isTrivial(pass.F->getModule())) {
     return StoreOwnershipQualifier::Trivial;
@@ -1517,7 +1517,7 @@ void LoadableStorageAllocation::allocateForArg(SILValue value) {
       ++II;
       loadBuilder.setInsertionPoint(II);
     }
-    if (!pass.F->hasQualifiedOwnership()) {
+    if (!pass.F->hasOwnership()) {
       load = loadBuilder.createLoad(applyInst->getLoc(), value,
                                     LoadOwnershipQualifier::Unqualified);
     } else {
@@ -1552,7 +1552,7 @@ void LoadableStorageAllocation::allocateForArg(SILValue value) {
   auto *applyOutlinedCopy =
       createOutlinedCopyCall(allocBuilder, value, allocInstr, pass);
 
-  if (!pass.F->hasQualifiedOwnership()) {
+  if (!pass.F->hasOwnership()) {
     loadCopy = allocBuilder.createLoad(applyOutlinedCopy->getLoc(), allocInstr,
                                        LoadOwnershipQualifier::Unqualified);
   } else {
@@ -1858,7 +1858,7 @@ static void createResultTyInstrAndLoad(LoadableStorageAllocation &allocator,
       currStructExtractInst->getType().getAddressType());
   // Load the struct element then see if we can get rid of the load:
   LoadInst *loadArg = nullptr;
-  if (!pass.F->hasQualifiedOwnership()) {
+  if (!pass.F->hasOwnership()) {
     loadArg = builder.createLoad(newInstr->getLoc(), newInstr,
                                  LoadOwnershipQualifier::Unqualified);
   } else {
@@ -1914,7 +1914,7 @@ static void rewriteFunction(StructLoweringState &pass,
 
           // Load the enum addr then see if we can get rid of the load:
           LoadInst *loadArg = nullptr;
-          if (!pass.F->hasQualifiedOwnership()) {
+          if (!pass.F->hasOwnership()) {
             loadArg = argBuilder.createLoad(
                 newArg->getLoc(), newArg, LoadOwnershipQualifier::Unqualified);
           } else {
@@ -2458,7 +2458,7 @@ void LoadableByAddress::recreateSingleApply(SILInstruction *applyInst) {
       if (oldValue->getType() != newValue->getType() &&
           !oldValue->getType().isAddress()) {
         LoadOwnershipQualifier ownership;
-        if (!F->hasQualifiedOwnership()) {
+        if (!F->hasOwnership()) {
           ownership = LoadOwnershipQualifier::Unqualified;
         } else if (newValue->getType().isTrivial(*getModule())) {
           ownership = LoadOwnershipQualifier::Trivial;

lib/ParseSIL/ParseSIL.cpp

@@ -5182,10 +5182,10 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
   bool AssumeUnqualifiedOwnershipWhenParsing =
     F->getModule().getOptions().AssumeUnqualifiedOwnershipWhenParsing;
   if (AssumeUnqualifiedOwnershipWhenParsing) {
-    F->setUnqualifiedOwnership();
+    F->setOwnershipEliminated();
   }
   B.setInsertionPoint(BB);
-  B.setHasOwnership(F->hasQualifiedOwnership());
+  B.setHasOwnership(F->hasOwnership());
   do {
     if (parseSILInstruction(B))
       return true;

lib/SIL/InstructionUtils.cpp

@@ -539,7 +539,7 @@ bool FunctionOwnershipEvaluator::evaluate(SILInstruction *I) {
   case OwnershipQualifiedKind::Unqualified: {
     // If we already know that the function has unqualified ownership, just
     // return early.
-    if (!F.get()->hasQualifiedOwnership())
+    if (!F.get()->hasOwnership())
       return true;
 
     // Ok, so we know at this point that we have qualified ownership. If we have
@@ -551,15 +551,15 @@ bool FunctionOwnershipEvaluator::evaluate(SILInstruction *I) {
     // Otherwise, set the function to have unqualified ownership. This will
     // ensure that no more Qualified instructions can be added to the given
     // function.
-    F.get()->setUnqualifiedOwnership();
+    F.get()->setOwnershipEliminated();
     return true;
   }
   case OwnershipQualifiedKind::Qualified: {
     // First check if our function has unqualified ownership. If we already do
     // have unqualified ownership, then we know that we have already seen an
     // unqualified ownership instruction. This means the function has both
     // qualified and unqualified instructions. =><=.
-    if (!F.get()->hasQualifiedOwnership())
+    if (!F.get()->hasOwnership())
       return false;
 
     // Ok, at this point we know that we are still qualified. Since functions

lib/SIL/SILBuilder.cpp

@@ -514,7 +514,7 @@ void SILBuilder::emitShallowDestructureValueOperation(
   }
 
   // Otherwise, we want to destructure add the destructure and return.
-  if (getFunction().hasQualifiedOwnership()) {
+  if (getFunction().hasOwnership()) {
     auto *DI = emitDestructureValueOperation(Loc, V);
     copy(DI->getResults(), std::back_inserter(Results));
     return;

lib/SIL/SILOwnershipVerifier.cpp

@@ -637,7 +637,7 @@ void SILInstruction::verifyOperandOwnership() const {
 
   // If the given function has unqualified ownership or we have been asked by
   // the user not to verify this function, there is nothing to verify.
-  if (!getFunction()->hasQualifiedOwnership() ||
+  if (!getFunction()->hasOwnership() ||
       !getFunction()->shouldVerifyOwnership())
     return;
 
@@ -701,7 +701,7 @@ void SILValue::verifyOwnership(SILModule &mod,
 
   // If the given function has unqualified ownership or we have been asked by
   // the user not to verify this function, there is nothing to verify.
-  if (!f->hasQualifiedOwnership() || !f->shouldVerifyOwnership())
+  if (!f->hasOwnership() || !f->shouldVerifyOwnership())
     return;
 
   ErrorBehaviorKind errorBehavior;
@@ -737,7 +737,7 @@ bool OwnershipChecker::checkValue(SILValue value) {
 
   // If the given function has unqualified ownership, there is nothing further
   // to verify.
-  if (!f->hasQualifiedOwnership())
+  if (!f->hasOwnership())
     return false;
 
   ErrorBehaviorKind errorBehavior(ErrorBehaviorKind::ReturnFalse);

lib/SIL/SILPrinter.cpp

@@ -561,7 +561,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
 
     // If SIL ownership is enabled and the given function has not had ownership
     // stripped out, print out ownership of SILArguments.
-    if (BB->getParent()->hasQualifiedOwnership()) {
+    if (BB->getParent()->hasOwnership()) {
       *this << getIDAndTypeAndOwnership(Args[0]);
       for (SILArgument *Arg : Args.drop_front()) {
         *this << ", " << getIDAndTypeAndOwnership(Arg);