---

yaml
---
r: 349102
b: refs/heads/master
c: e4504af
h: refs/heads/master

Author: hamishknight

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9061d3da71063ab8cce9ecc70fd1f4b69fbf614d
+refs/heads/master: e4504af618c33caaf4cf23d69c036c0c1c95498f
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/benchmark/scripts/run_smoke_bench

@@ -93,6 +93,10 @@ def main():
     argparser.add_argument(
         '-num-samples', type=int,
         help='The (minimum) number of samples to run', default=3)
+    argparser.add_argument(
+        '-num-reruns', type=int,
+        help="The number of re-runs until it's assumed to be a real change",
+        default=8)
     argparser.add_argument(
         '-platform', type=str,
         help='The benchmark build platform', default='macosx')
@@ -120,7 +124,7 @@ def test_opt_levels(args):
             if test_performance(opt_level, args.oldbuilddir[0],
                                 args.newbuilddir[0],
                                 float(args.threshold) / 100, args.num_samples,
-                                output_file):
+                                args.num_reruns, output_file):
                 changes = True
 
         # There is no point in reporting code size for Onone.
@@ -171,7 +175,7 @@ def merge(results, other_results):
 
 
 def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
-                     output_file):
+                     num_reruns, output_file):
     """Detect performance changes in benchmarks.
 
     Start fast with few samples per benchmark and gradually spend more time
@@ -185,7 +189,7 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
     tests = TestComparator(results[0], results[1], threshold)
     changed = tests.decreased + tests.increased
 
-    while len(changed) > 0 and unchanged_length_count < 10:
+    while len(changed) > 0 and unchanged_length_count < num_reruns:
         i += 1
         if VERBOSE:
             log('        test again: ' + str([test.name for test in changed]))

trunk/include/swift/SIL/MemoryLifetime.h

@@ -22,6 +22,16 @@
 
 namespace swift {
 
+void printBitsAsArray(llvm::raw_ostream &OS, const SmallBitVector &bits);
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const SmallBitVector &bits) {
+  printBitsAsArray(OS, bits);
+  return OS;
+}
+
+void dumpBits(const SmallBitVector &bits);
+
 /// The MemoryLocations utility provides functions to analyze memory locations.
 ///
 /// Memory locations are limited to addresses which are guaranteed to

trunk/include/swift/SIL/SILArgumentConvention.h

@@ -17,18 +17,6 @@
 
 namespace swift {
 
-enum class InoutAliasingAssumption {
-  /// Assume that an inout indirect parameter may alias other objects.
-  /// This is the safe assumption an optimization should make if it may break
-  /// memory safety in case the inout aliasing rule is violation.
-  Aliasing,
-
-  /// Assume that an inout indirect parameter cannot alias other objects.
-  /// Optimizations should only use this if they can guarantee that they will
-  /// not break memory safety even if the inout aliasing rule is violated.
-  NotAliasing
-};
-
 /// Conventions for apply operands and function-entry arguments in SIL.
 ///
 /// This is simply a union of ParameterConvention and ResultConvention
@@ -142,19 +130,14 @@ struct SILArgumentConvention {
   }
 
   /// Returns true if \p Value is a not-aliasing indirect parameter.
-  /// The \p isInoutAliasing specifies what to assume about the inout
-  /// convention.
-  /// See InoutAliasingAssumption.
-  bool isNotAliasedIndirectParameter(InoutAliasingAssumption isInoutAliasing) {
+  bool isNotAliasedIndirectParameter() {
     switch (Value) {
     case SILArgumentConvention::Indirect_In:
     case SILArgumentConvention::Indirect_In_Constant:
     case SILArgumentConvention::Indirect_Out:
     case SILArgumentConvention::Indirect_In_Guaranteed:
-      return true;
-
     case SILArgumentConvention::Indirect_Inout:
-      return isInoutAliasing == InoutAliasingAssumption::NotAliasing;
+      return true;
 
     case SILArgumentConvention::Indirect_InoutAliasable:
     case SILArgumentConvention::Direct_Unowned:

trunk/include/swift/SILOptimizer/Analysis/ValueTracking.h

@@ -26,16 +26,14 @@ namespace swift {
 /// any other pointer in the function.
 /// The \p assumeInoutIsNotAliasing specifies in no-aliasing is assumed for
 /// the @inout convention. See swift::isNotAliasedIndirectParameter().
-bool isNotAliasingArgument(SILValue V, InoutAliasingAssumption isInoutAliasing =
-                                         InoutAliasingAssumption::Aliasing);
+bool isNotAliasingArgument(SILValue V);
 
 /// Returns true if \p V is local inside its function. This means its underlying
 /// object either is a non-aliasing function argument or a locally allocated
 /// object.
 /// The \p assumeInoutIsNotAliasing specifies in no-aliasing is assumed for
 /// the @inout convention. See swift::isNotAliasedIndirectParameter().
-bool pointsToLocalObject(SILValue V, InoutAliasingAssumption isInoutAliasing =
-                                         InoutAliasingAssumption::Aliasing);
+bool pointsToLocalObject(SILValue V);
 
 enum class IsZeroKind {
   Zero,

trunk/lib/IRGen/GenCast.cpp

@@ -638,8 +638,12 @@ void irgen::emitScalarExistentialDowncast(IRGenFunction &IGF,
   bool checkSuperclassConstraint = false;
   if (hasSuperclassConstraint) {
     Type srcSuperclassType = srcInstanceType;
-    if (srcSuperclassType->isExistentialType())
+    if (srcSuperclassType->isExistentialType()) {
       srcSuperclassType = srcSuperclassType->getSuperclass();
+      // Look for an AnyObject superclass (getSuperclass() returns nil).
+      if (!srcSuperclassType && srcInstanceType->isClassExistentialType())
+        checkSuperclassConstraint = true;
+    }
     if (srcSuperclassType) {
       checkSuperclassConstraint =
         !destInstanceType->getSuperclass()->isExactSuperclassOf(

trunk/lib/SIL/MemoryLifetime.cpp

@@ -28,26 +28,28 @@ llvm::cl::opt<bool> DontAbortOnMemoryLifetimeErrors(
     llvm::cl::desc("Don't abort compliation if the memory lifetime checker "
                    "detects an error."));
 
-namespace swift {
-namespace {
-
-//===----------------------------------------------------------------------===//
-//                            Utility functions
-//===----------------------------------------------------------------------===//
-
 /// Debug dump a location bit vector.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
-                              const SmallBitVector &bits) {
+void swift::printBitsAsArray(llvm::raw_ostream &OS, const SmallBitVector &bits) {
   const char *separator = "";
   OS << '[';
   for (int idx = bits.find_first(); idx >= 0; idx = bits.find_next(idx)) {
     OS << separator << idx;
     separator = ",";
   }
   OS << ']';
-  return OS;
 }
 
+void swift::dumpBits(const SmallBitVector &bits) {
+  llvm::dbgs() << bits << '\n';
+}
+
+namespace swift {
+namespace {
+
+//===----------------------------------------------------------------------===//
+//                            Utility functions
+//===----------------------------------------------------------------------===//
+
 /// Enlarge the bitset if needed to set the bit with \p idx.
 static void setBitAndResize(SmallBitVector &bits, unsigned idx) {
   if (bits.size() <= idx)
@@ -240,10 +242,6 @@ void MemoryLocations::dump() const {
   }
 }
 
-void MemoryLocations::dumpBits(const Bits &bits) {
-  llvm::errs() << bits << '\n';
-}
-
 void MemoryLocations::clear() {
   locations.clear();
   addr2LocIdx.clear();

trunk/lib/SILOptimizer/Analysis/ValueTracking.cpp

@@ -23,14 +23,13 @@
 using namespace swift;
 using namespace swift::PatternMatch;
 
-bool swift::isNotAliasingArgument(SILValue V,
-                                  InoutAliasingAssumption isInoutAliasing) {
+bool swift::isNotAliasingArgument(SILValue V) {
   auto *Arg = dyn_cast<SILFunctionArgument>(V);
   if (!Arg)
     return false;
 
   SILArgumentConvention Conv = Arg->getArgumentConvention();
-  return Conv.isNotAliasedIndirectParameter(isInoutAliasing);
+  return Conv.isNotAliasedIndirectParameter();
 }
 
 /// Check if the parameter \V is based on a local object, e.g. it is an
@@ -81,10 +80,9 @@ static bool isLocalObject(SILValue Obj) {
   return true;
 }
 
-bool swift::pointsToLocalObject(SILValue V,
-                                InoutAliasingAssumption isInoutAliasing) {
+bool swift::pointsToLocalObject(SILValue V) {
   V = getUnderlyingObject(V);
-  return isLocalObject(V) || isNotAliasingArgument(V, isInoutAliasing);
+  return isLocalObject(V) || isNotAliasingArgument(V);
 }
 
 /// Check if the value \p Value is known to be zero, non-zero or unknown.

trunk/lib/SILOptimizer/Transforms/DeadStoreElimination.cpp

@@ -60,6 +60,7 @@
 #include "swift/SIL/Projection.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/MemoryLifetime.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
@@ -269,6 +270,8 @@ class BlockState {
     init(LocationNum, Optimistic);
   }
 
+  void dump();
+
   /// Initialize the bitvectors for the current basic block.
   void init(unsigned LocationNum, bool Optimistic);
 
@@ -448,6 +451,8 @@ enum class ProcessKind {
              llvm::SpecificBumpPtrAllocator<BlockState> &BPA) 
     : Mod(M), F(F), PM(PM), AA(AA), TE(TE), EAFI(EAFI), BPA(BPA) {}
 
+  void dump();
+
   /// Entry point for dead store elimination.
   bool run();
 
@@ -481,6 +486,12 @@ enum class ProcessKind {
 
 } // end anonymous namespace
 
+void BlockState::dump() {
+  llvm::dbgs() << "  block " << BB->getDebugID() << ": in=" << BBWriteSetIn
+               << ", out=" << BBWriteSetOut << ", mid=" << BBWriteSetMid
+               << ", gen=" << BBGenSet << ", kill=" << BBKillSet << '\n';
+}
+
 void BlockState::init(unsigned LocationNum, bool Optimistic) {
   // For function that requires just 1 iteration of the data flow to converge
   // we set the initial state of BBWriteSetIn to 0.
@@ -513,6 +524,21 @@ void BlockState::init(unsigned LocationNum, bool Optimistic) {
   BBDeallocateLocation.resize(LocationNum, false);
 }
 
+#if __has_attribute(used)
+__attribute((used))
+#endif
+void DSEContext::dump() {
+  llvm::dbgs() << "Locations:\n";
+  unsigned idx = 0;
+  for (const LSLocation &loc : LocationVault) {
+    llvm::dbgs() << "  #" << idx << ": " << loc.getBase();
+    ++idx;
+  }
+  for (SILBasicBlock &BB : *F) {
+    getBlockState(&BB)->dump();
+  }
+}
+
 unsigned DSEContext::getLocationBit(const LSLocation &Loc) {
   // Return the bit position of the given Loc in the LocationVault. The bit
   // position is then used to set/reset the bitvector kept by each BlockState.
@@ -691,6 +717,10 @@ void DSEContext::mergeSuccessorLiveIns(SILBasicBlock *BB) {
   // dead for block with no successor.
   BlockState *C = getBlockState(BB);
   if (BB->succ_empty()) {
+    if (isa<UnreachableInst>(BB->getTerminator())) {
+      C->BBWriteSetOut.set();
+      return;
+    }
     C->BBWriteSetOut |= C->BBDeallocateLocation;
     return;
   }

trunk/lib/Sema/CSDiagnostics.cpp

@@ -542,26 +542,11 @@ void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
 
 bool MissingConformanceFailure::diagnoseAsError() {
   auto *anchor = getAnchor();
-  auto ownerType = getOwnerType();
   auto nonConformingType = getLHS();
   auto protocolType = getRHS();
 
-  auto getArgumentAt = [](const ApplyExpr *AE, unsigned index) -> Expr * {
-    assert(AE);
-
-    auto *arg = AE->getArg();
-    if (auto *TE = dyn_cast<TupleExpr>(arg))
-      return TE->getElement(index);
-
-    assert(index == 0);
-    if (auto *PE = dyn_cast<ParenExpr>(arg))
-      return PE->getSubExpr();
-
-    return arg;
-  };
-
   // If this is a requirement of a pattern-matching operator,
-  // let's see whether argument is already has a fix associated
+  // let's see whether argument already has a fix associated
   // with it and if so skip conformance error, otherwise we'd
   // produce an unrelated `<type> doesn't conform to Equatable protocol`
   // diagnostic.
@@ -588,43 +573,14 @@ bool MissingConformanceFailure::diagnoseAsError() {
   if (diagnoseAsAmbiguousOperatorRef())
     return true;
 
-  Optional<unsigned> atParameterPos;
-  // Sometimes fix is recorded by type-checking sub-expression
-  // during normal diagnostics, in such case call expression
-  // is unavailable.
-  if (Apply) {
-    if (auto *fnType = ownerType->getAs<AnyFunctionType>()) {
-      auto parameters = fnType->getParams();
-      for (auto index : indices(parameters)) {
-        if (parameters[index].getOldType()->isEqual(nonConformingType)) {
-          atParameterPos = index;
-          break;
-        }
-      }
-    }
-  }
-
   if (nonConformingType->isObjCExistentialType()) {
     emitDiagnostic(anchor->getLoc(), diag::protocol_does_not_conform_static,
                    nonConformingType, protocolType);
     return true;
   }
 
-  if (diagnoseTypeCannotConform((atParameterPos ?
-                                getArgumentAt(Apply, *atParameterPos) : anchor),
-                                nonConformingType, protocolType)) {
-      return true;
-  }
-
-  if (atParameterPos) {
-    // Requirement comes from one of the parameter types,
-    // let's try to point diagnostic to the argument expression.
-    auto *argExpr = getArgumentAt(Apply, *atParameterPos);
-    emitDiagnostic(argExpr->getLoc(),
-                   diag::cannot_convert_argument_value_protocol,
-                   nonConformingType, protocolType);
+  if (diagnoseTypeCannotConform(anchor, nonConformingType, protocolType))
     return true;
-  }
 
   // If none of the special cases could be diagnosed,
   // let's fallback to the most general diagnostic.

trunk/test/ClangImporter/newtype_conformance.swift

@@ -13,12 +13,15 @@ import MoreSwiftNewtypes
 
 func acceptEquatable<T: Equatable>(_: T) {}
 func acceptHashable<T: Hashable>(_: T) {}
+// expected-note@-1 {{where 'T' = 'WrappedRef'}}
+// expected-note@-2 {{where 'T' = 'WrappedValue'}}
 func acceptComparable<T: Comparable>(_: T) {}
+// expected-note@-1 {{where 'T' = 'NSNotification.Name'}}
 
 func testNewTypeWrapper(x: NSNotification.Name, y: NSNotification.Name) {
   acceptEquatable(x)
   acceptHashable(x)
-  acceptComparable(x) // expected-error {{does not conform to expected type 'Comparable'}}
+  acceptComparable(x) // expected-error {{global function 'acceptComparable' requires that 'NSNotification.Name' conform to 'Comparable'}}
 
   _ = x == y
   _ = x != y
@@ -30,6 +33,6 @@ func testNewTypeWrapper(x: NSNotification.Name, y: NSNotification.Name) {
 func testCustomWrappers(wrappedRef: WrappedRef, wrappedValue: WrappedValue) {
   acceptEquatable(wrappedRef)
   acceptEquatable(wrappedValue)
-  acceptHashable(wrappedRef) // expected-error {{does not conform to expected type 'Hashable'}}
-  acceptHashable(wrappedValue) // expected-error {{does not conform to expected type 'Hashable'}}
+  acceptHashable(wrappedRef) // expected-error {{global function 'acceptHashable' requires that 'WrappedRef' conform to 'Hashable'}}
+  acceptHashable(wrappedValue) // expected-error {{global function 'acceptHashable' requires that 'WrappedValue' conform to 'Hashable'}}
 }