---

yaml
---
r: 314869
b: refs/heads/master
c: e51086b
h: refs/heads/master
i:
  314867: a049a9f

Author: jrose-apple

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 847dd2f28f3b26971324aa2c48595463437d7c32
+refs/heads/master: e51086bcc1e88f47eb132ca91aebd76508417bdd
 refs/heads/master-next: 66a7e661ff8e88e2d4efab3e430197a7a941e352
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/AST/ASTVerifier.cpp

@@ -2362,14 +2362,6 @@ class Verifier : public ASTWalker {
         }
       }
 
-      if (VD->isFinal() != VD->getAttrs().hasAttribute<FinalAttr>()) {
-        Out << "decl should be final iff it has FinalAttr, but isFinal() = "
-            << VD->isFinal() << " and hasAttribute<FinalAttr>() = "
-            << VD->getAttrs().hasAttribute<FinalAttr>() << "\n";
-        VD->dump(Out);
-        abort();
-      }
-
       verifyCheckedBase(VD);
     }
 

trunk/lib/SIL/LinearLifetimeChecker.cpp

@@ -42,8 +42,14 @@ namespace {
 using BrPropUserAndBlockPair = std::pair<BranchPropagatedUser, SILBasicBlock *>;
 
 struct State {
-  /// The value that we are checking.
-  SILValue value;
+  /// If we are checking for a specific value, this is that value. This is only
+  /// used for diagnostic purposes. The algorithm if this is set works on the
+  /// parent block of the value.
+  Optional<SILValue> value;
+
+  /// The block where the live range begins. If the field value is not None,
+  /// then this is value->getParentBlock();
+  SILBasicBlock *beginBlock;
 
   /// The result error object that use to signal either that no errors were
   /// found or if errors are found the specific type of error that was found.
@@ -75,8 +81,15 @@ struct State {
   State(SILValue value, SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
         ErrorBehaviorKind errorBehavior,
         SmallVectorImpl<SILBasicBlock *> *leakingBlocks)
-      : value(value), error(errorBehavior), visitedBlocks(visitedBlocks),
-        leakingBlocks(leakingBlocks) {}
+      : value(value), beginBlock(value->getParentBlock()), error(errorBehavior),
+        visitedBlocks(visitedBlocks), leakingBlocks(leakingBlocks) {}
+
+  State(SILBasicBlock *beginBlock,
+        SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+        ErrorBehaviorKind errorBehavior,
+        SmallVectorImpl<SILBasicBlock *> *leakingBlocks)
+      : value(), beginBlock(beginBlock), error(errorBehavior),
+        visitedBlocks(visitedBlocks), leakingBlocks(leakingBlocks) {}
 
   void initializeAllNonConsumingUses(
       ArrayRef<BranchPropagatedUser> nonConsumingUsers);
@@ -183,7 +196,7 @@ void State::initializeAllConsumingUses(
     // If this user is in the same block as the value, do not visit
     // predecessors. We must be extra tolerant here since we allow for
     // unreachable code.
-    if (userBlock == value->getParentBlock())
+    if (userBlock == beginBlock)
       continue;
 
     // Then for each predecessor of this block...
@@ -203,10 +216,15 @@ void State::initializeConsumingUse(BranchPropagatedUser consumingUser,
     return;
 
   error.handleOverConsume([&] {
-    llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
-                 << "Found over consume?!\n"
-                 << "Value: " << *value << "User: " << *consumingUser
-                 << "Block: bb" << userBlock->getDebugID() << "\n\n";
+    llvm::errs() << "Function: '" << beginBlock->getParent()->getName() << "'\n"
+                 << "Found over consume?!\n";
+    if (auto v = value) {
+      llvm::errs() << "Value: " << *value;
+    } else {
+      llvm::errs() << "Value: N/A\n";
+    }
+    llvm::errs() << "User: " << *consumingUser << "Block: bb"
+                 << userBlock->getDebugID() << "\n\n";
   });
 }
 
@@ -228,10 +246,16 @@ void State::checkForSameBlockUseAfterFree(BranchPropagatedUser consumingUser,
   // the cond branch user is in a previous block. So just bail early.
   if (consumingUser.isCondBranchUser()) {
     error.handleUseAfterFree([&]() {
-      llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
+      llvm::errs() << "Function: '" << beginBlock->getParent()->getName()
+                   << "'\n"
                    << "Found use after free?!\n"
-                   << "Value: " << *value
-                   << "Consuming User: " << *consumingUser
+                   << "Value: ";
+      if (auto v = value) {
+        llvm::errs() << *v;
+      } else {
+        llvm::errs() << "N/A. \n";
+      }
+      llvm::errs() << "Consuming User: " << *consumingUser
                    << "Non Consuming User: " << *iter->second << "Block: bb"
                    << userBlock->getDebugID() << "\n\n";
     });
@@ -255,10 +279,16 @@ void State::checkForSameBlockUseAfterFree(BranchPropagatedUser consumingUser,
                      return nonConsumingUser == &i;
                    }) != userBlock->end()) {
     error.handleUseAfterFree([&] {
-      llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
+      llvm::errs() << "Function: '" << beginBlock->getParent()->getName()
+                   << "'\n"
                    << "Found use after free?!\n"
-                   << "Value: " << *value
-                   << "Consuming User: " << *consumingUser
+                   << "Value: ";
+      if (auto v = value) {
+        llvm::errs() << *v;
+      } else {
+        llvm::errs() << "N/A. \n";
+      }
+      llvm::errs() << "Consuming User: " << *consumingUser
                    << "Non Consuming User: " << *iter->second << "Block: bb"
                    << userBlock->getDebugID() << "\n\n";
     });
@@ -287,10 +317,17 @@ void State::checkPredsForDoubleConsume(BranchPropagatedUser consumingUser,
   }
 
   error.handleOverConsume([&] {
-    llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
+    llvm::errs() << "Function: '" << beginBlock->getParent()->getName() << "'\n"
                  << "Found over consume?!\n"
-                 << "Value: " << *value << "User: " << *consumingUser
-                 << "Block: bb" << userBlock->getDebugID() << "\n\n";
+                 << "Value: ";
+    if (auto v = value) {
+      llvm::errs() << *v;
+    } else {
+      llvm::errs() << "N/A. \n";
+    }
+
+    llvm::errs() << "User: " << *consumingUser << "Block: bb"
+                 << userBlock->getDebugID() << "\n\n";
   });
 }
 
@@ -310,10 +347,16 @@ void State::checkPredsForDoubleConsume(SILBasicBlock *userBlock) {
   }
 
   error.handleOverConsume([&] {
-    llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
+    llvm::errs() << "Function: '" << beginBlock->getParent()->getName() << "'\n"
                  << "Found over consume?!\n"
-                 << "Value: " << *value << "Block: bb"
-                 << userBlock->getDebugID() << "\n\n";
+                 << "Value: ";
+    if (auto v = value) {
+      llvm::errs() << *v;
+    } else {
+      llvm::errs() << "N/A. \n";
+    }
+
+    llvm::errs() << "Block: bb" << userBlock->getDebugID() << "\n\n";
   });
 }
 
@@ -370,7 +413,7 @@ void State::performDataflow(DeadEndBlocks &deBlocks) {
     // further to do since we do not want to visit the predecessors of our
     // dominating block. On the other hand, we do want to add its successors to
     // the successorBlocksThatMustBeVisited set.
-    if (block == value->getParentBlock())
+    if (block == beginBlock)
       continue;
 
     // Then for each predecessor of this block:
@@ -405,11 +448,16 @@ void State::checkDataflowEndState(DeadEndBlocks &deBlocks) {
 
     // If we are supposed to error on leaks, do so now.
     error.handleLeak([&] {
-      llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
+      llvm::errs() << "Function: '" << beginBlock->getParent()->getName()
+                   << "'\n"
                    << "Error! Found a leak due to a consuming post-dominance "
-                      "failure!\n"
-                   << "    Value: " << *value
-                   << "    Post Dominating Failure Blocks:\n";
+                      "failure!\n";
+      if (auto v = value) {
+        llvm::errs() << "Value: " << *value;
+      } else {
+        llvm::errs() << "Value: N/A\n";
+      }
+      llvm::errs() << "    Post Dominating Failure Blocks:\n";
       for (auto *succBlock : successorBlocksThatMustBeVisited) {
         llvm::errs() << "        bb" << succBlock->getDebugID();
       }
@@ -434,10 +482,18 @@ void State::checkDataflowEndState(DeadEndBlocks &deBlocks) {
     }
 
     error.handleUseAfterFree([&] {
-      llvm::errs() << "Function: '" << value->getFunction()->getName() << "'\n"
+      llvm::errs() << "Function: '" << beginBlock->getParent()->getName()
+                   << "'\n"
                    << "Found use after free due to unvisited non lifetime "
                       "ending uses?!\n"
-                   << "Value: " << *value << "    Remaining Users:\n";
+                   << "Value: ";
+      if (auto v = value) {
+        llvm::errs() << *v;
+      } else {
+        llvm::errs() << "N/A. \n";
+      }
+
+      llvm::errs() << "    Remaining Users:\n";
       for (auto &pair : blocksWithNonConsumingUses) {
         llvm::errs() << "User:" << *pair.second << "Block: bb"
                      << pair.first->getDebugID() << "\n";

trunk/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp

@@ -159,6 +159,8 @@ void ExistentialSpecializerCloner::cloneArguments(
     GenericTypeParamType *GenericParam = iter->second;
     SILType GenericSILType =
         NewF.getLoweredType(NewF.mapTypeIntoContext(GenericParam));
+    GenericSILType = GenericSILType.getCategoryType(
+                                          ArgDesc.Arg->getType().getCategory());
     auto *NewArg = ClonedEntryBB->createFunctionArgument(GenericSILType);
     NewArg->setOwnershipKind(ValueOwnershipKind(
         NewF, GenericSILType, ArgDesc.Arg->getArgumentConvention()));
@@ -173,6 +175,7 @@ void ExistentialSpecializerCloner::cloneArguments(
         Ctx.AllocateCopy(NewConformances);
     auto ExistentialRepr =
         ArgDesc.Arg->getType().getPreferredExistentialRepresentation(M);
+    auto &EAD = ExistentialArgDescriptor[ArgDesc.Index];
     switch (ExistentialRepr) {
     case ExistentialRepresentation::Opaque: {
       /// Create this sequence for init_existential_addr.:
@@ -190,7 +193,7 @@ void ExistentialSpecializerCloner::cloneArguments(
           InsertLoc, ASI, NewArg->getType().getASTType(), NewArg->getType(),
           Conformances);
 
-      bool origConsumed = ExistentialArgDescriptor[ArgDesc.Index].isConsumed;
+      bool origConsumed = EAD.isConsumed;
       // If the existential is not consumed in the function body, then the one
       // we introduce here needs cleanup.
       if (!origConsumed)
@@ -204,16 +207,32 @@ void ExistentialSpecializerCloner::cloneArguments(
       break;
     }
     case ExistentialRepresentation::Class: {
+      SILValue NewArgValue = NewArg;
+      if (!NewArg->getType().isObject()) {
+        NewArgValue = NewFBuilder.createLoad(InsertLoc, NewArg,
+                                         LoadOwnershipQualifier::Unqualified);
+      }
+      
       // FIXME_ownership: init_existential_ref always takes ownership of the
       // incoming reference. If the argument convention is borrowed
       // (!isConsumed), then we should create a copy_value here and add this new
       // existential to the CleanupValues vector.
 
       ///  Simple case: Create an init_existential.
       /// %5 = init_existential_ref %0 : $T : $T, $P
-      auto *InitRef = NewFBuilder.createInitExistentialRef(
-          InsertLoc, ArgDesc.Arg->getType(), NewArg->getType().getASTType(),
-          NewArg, Conformances);
+      SILValue InitRef = NewFBuilder.createInitExistentialRef(
+          InsertLoc, ArgDesc.Arg->getType().getObjectType(),
+          NewArg->getType().getASTType(),
+          NewArgValue, Conformances);
+      
+      if (!NewArg->getType().isObject()) {
+        auto alloc = NewFBuilder.createAllocStack(InsertLoc,
+                                                  InitRef->getType());
+        NewFBuilder.createStore(InsertLoc, InitRef, alloc,
+                                StoreOwnershipQualifier::Unqualified);
+        InitRef = alloc;
+        AllocStackInsts.push_back(alloc);
+      }
 
       entryArgs.push_back(InitRef);
       break;
@@ -369,7 +388,8 @@ void ExistentialTransform::populateThunkBody() {
   /// Create a basic block and the function arguments.
   auto *ThunkBody = F->createBasicBlock();
   for (auto &ArgDesc : ArgumentDescList) {
-    ThunkBody->createFunctionArgument(ArgDesc.Arg->getType(), ArgDesc.Decl);
+    auto argumentType = ArgDesc.Arg->getType();
+    ThunkBody->createFunctionArgument(argumentType, ArgDesc.Decl);
   }
 
   /// Builder to add new instructions in the Thunk.
@@ -394,7 +414,11 @@ void ExistentialTransform::populateThunkBody() {
   SmallVector<SILValue, 8> ApplyArgs;
   // Maintain a list of arg values to be destroyed. These are consumed by the
   // convention and require a copy.
-  SmallVector<CopyAddrInst *, 8> TempCopyAddrInsts;
+  struct Temp {
+    SILValue DeallocStackEntry;
+    SILValue DestroyValue;
+  };
+  SmallVector<Temp, 8> Temps;
   SmallDenseMap<GenericTypeParamType *, Type> GenericToOpenedTypeMap;
   for (auto &ArgDesc : ArgumentDescList) {
     auto iter = ArgToGenericTypeMap.find(ArgDesc.Index);
@@ -422,22 +446,32 @@ void ExistentialTransform::populateThunkBody() {
           // must pass in a copy.
           auto *ASI =
             Builder.createAllocStack(Loc, OpenedSILType);
-          auto *CAI =
-              Builder.createCopyAddr(Loc, archetypeValue, ASI, IsNotTake,
-                                     IsInitialization_t::IsInitialization);
-          TempCopyAddrInsts.push_back(CAI);
+          Builder.createCopyAddr(Loc, archetypeValue, ASI, IsNotTake,
+                                 IsInitialization_t::IsInitialization);
+          Temps.push_back({ASI, OrigOperand});
           calleeArg = ASI;
         }
         ApplyArgs.push_back(calleeArg);
         break;
       }
       case ExistentialRepresentation::Class: {
-        /// If the operand is not object type, we would need an explicit load.
+        // If the operand is not object type, we need an explicit load.
+        SILValue OrigValue = OrigOperand;
+        if (!OrigOperand->getType().isObject()) {
+          OrigValue = Builder.createLoad(Loc, OrigValue,
+                                         LoadOwnershipQualifier::Unqualified);
+        }
         // OpenExistentialRef forwards ownership, so it does the right thing
         // regardless of whether the argument is borrowed or consumed.
-        assert(OrigOperand->getType().isObject());
         archetypeValue =
-            Builder.createOpenExistentialRef(Loc, OrigOperand, OpenedSILType);
+            Builder.createOpenExistentialRef(Loc, OrigValue, OpenedSILType);
+        if (!OrigOperand->getType().isObject()) {
+          SILValue ASI = Builder.createAllocStack(Loc, OpenedSILType);
+          Builder.createStore(Loc, archetypeValue, ASI,
+                              StoreOwnershipQualifier::Unqualified);
+          Temps.push_back({ASI, SILValue()});
+          archetypeValue = ASI;
+        }
         ApplyArgs.push_back(archetypeValue);
         break;
       }
@@ -511,7 +545,7 @@ void ExistentialTransform::populateThunkBody() {
     ReturnValue = Builder.createApply(Loc, FRI, SubMap, ApplyArgs);
   }
   auto cleanupLoc = RegularLocation::getAutoGeneratedLocation();
-  for (CopyAddrInst *CAI : reversed(TempCopyAddrInsts)) {
+  for (auto &Temp : reversed(Temps)) {
     // The original argument was copied into a temporary and consumed by the
     // callee as such:
     //   bb (%consumedExistential : $*Protocol)
@@ -523,10 +557,10 @@ void ExistentialTransform::populateThunkBody() {
     // Destroy the original arument and deallocation the temporary:
     //     destroy_addr %consumedExistential : $*Protocol
     //     dealloc_stack %temp : $*T
-    auto *consumedExistential = cast<SILFunctionArgument>(
-        cast<OpenExistentialAddrInst>(CAI->getSrc())->getOperand());
-    Builder.createDestroyAddr(cleanupLoc, consumedExistential);
-    Builder.createDeallocStack(cleanupLoc, CAI->getDest());
+    if (Temp.DestroyValue)
+      Builder.createDestroyAddr(cleanupLoc, Temp.DestroyValue);
+    if (Temp.DeallocStackEntry)
+      Builder.createDeallocStack(cleanupLoc, Temp.DeallocStackEntry);
   }
   /// Set up the return results.
   if (NewF->isNoReturnFunction()) {