---

yaml
---
r: 349095
b: refs/heads/master
c: 7032e65
h: refs/heads/master
i:
  349093: 72e1905
  349091: 8a23159
  349087: b44ac4d

Author: xedin

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d90117bb8a7e953e080fbb3f6d22e5502e7aa51b
+refs/heads/master: 7032e652eec8206f2597d57014855b284071576e
 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/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/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/test/IRGen/casts.sil

@@ -359,3 +359,51 @@ entry(%a : $OA):
   %b = unconditional_checked_cast %a : $OA to $OB
   return %b : $OB
 }
+
+protocol P {}
+protocol PAnyObject: AnyObject {}
+class C {}
+sil_vtable C {}
+
+// CHECK-LABEL: define{{.*}} @cast_protocol_composition_with_anyobject
+// CHECK: [[C:%.*]] = call swiftcc %swift.metadata_response @"$s5casts1CCMa"
+// CHECK: [[C_META:%.*]] = extractvalue %swift.metadata_response [[C]], 0
+// CHECK: call { i8*, i8** } @dynamic_cast_existential_1_superclass_conditional({{.*}}, %swift.type* [[C_META]], %swift.protocol* {{.*}}@"$s5casts1PMp"
+
+sil @cast_protocol_composition_with_anyobject : $@convention(thin) (@owned P & AnyObject ) -> @owned Optional<C & P> {
+bb0(%0: $P & AnyObject):
+  checked_cast_br %0 : $P & AnyObject to $C & P, bb1, bb2
+
+bb1(%2 : $C & P):
+  %3 = enum $Optional<C & P>, #Optional.some!enumelt.1, %2 : $C & P
+  br bb3(%3 : $Optional<C & P>)
+
+bb2:
+  strong_release %0 : $P & AnyObject
+  %6 = enum $Optional<C & P>, #Optional.none!enumelt
+  br bb3(%6 : $Optional<C & P>)
+
+bb3(%11 : $Optional<C & P>):
+  return %11 : $Optional<C & P>
+}
+
+// CHECK-LABEL: define{{.*}} @cast_protocol_with_anyobject
+// CHECK: [[C:%.*]] = call swiftcc %swift.metadata_response @"$s5casts1CCMa"
+// CHECK: [[C_META:%.*]] = extractvalue %swift.metadata_response [[C]], 0
+// CHECK: call { i8*, i8** } @dynamic_cast_existential_1_superclass_conditional({{.*}}, %swift.type* [[C_META]], %swift.protocol* {{.*}}@"$s5casts10PAnyObjectMp"
+sil @cast_protocol_with_anyobject : $@convention(thin) (@owned PAnyObject ) -> @owned Optional<C & PAnyObject> {
+bb0(%0: $PAnyObject):
+  checked_cast_br %0 : $PAnyObject to $C & PAnyObject, bb1, bb2
+
+bb1(%2 : $C & PAnyObject):
+  %3 = enum $Optional<C & PAnyObject>, #Optional.some!enumelt.1, %2 : $C & PAnyObject
+  br bb3(%3 : $Optional<C & PAnyObject>)
+
+bb2:
+  strong_release %0 : $PAnyObject
+  %6 = enum $Optional<C & PAnyObject>, #Optional.none!enumelt
+  br bb3(%6 : $Optional<C & PAnyObject>)
+
+bb3(%11 : $Optional<C & PAnyObject>):
+  return %11 : $Optional<C & PAnyObject>
+}

trunk/test/Interpreter/casts.swift

@@ -122,3 +122,23 @@ Casts.test("testConditionalBridgedCastFromSwiftToNSObjectDerivedClass") {
   }
   expectEqual(0, LifetimeTracked.instances)
 }
+
+protocol Q {}
+class K { }
+class D: Q {}
+typealias AnyQ = Q & AnyObject
+typealias KQ = K & Q
+
+Casts.test("testCastProtocolCompoWithAnyObjectToProtocolCompoTypeSuperclass") {
+  let shouldBeNil = (D() as AnyQ) as? KQ
+  expectNil(shouldBeNil)
+}
+
+protocol QAny: AnyObject {}
+typealias KQAny = K & QAny
+class F: QAny {}
+
+Casts.test("testCastProtocolWithAnyObjectToProtocolCompoTypeSuperclass") {
+  let shouldBeNil = (F() as QAny) as? KQAny
+  expectNil(shouldBeNil)
+}

trunk/test/SILOptimizer/dead_store_elim.sil

@@ -291,6 +291,29 @@ bb3:
   return %9999 : $()
 }
 
+// CHECK-LABEL: sil @handle_unreachable : $@convention(thin) (@inout Builtin.Int32) -> () {
+// CHECK: bb0
+// CHECK-NEXT: integer_literal
+// CHECK-NEXT: cond_br
+// CHECK: return
+sil @handle_unreachable : $@convention(thin) (@inout Builtin.Int32) -> () {
+bb0(%0 : $*Builtin.Int32):
+  %1 = integer_literal $Builtin.Int32, 0
+  store %1 to %0 : $*Builtin.Int32
+  cond_br undef, bb1, bb2
+
+bb1:
+  unreachable
+
+bb2:
+  br bb3
+
+bb3:
+  store %1 to %0 : $*Builtin.Int32
+  %9999 = tuple()
+  return %9999 : $()
+}
+
 // CHECK-LABEL: sil @post_dominating_dead_store_partial : $@convention(thin) (@inout Builtin.Int32) -> () {
 // CHECK: bb0(
 // CHECK-NOT: {{ store}}