---

yaml
---
r: 345061
b: refs/heads/master
c: ad3238f
h: refs/heads/master
i:
  345059: ac39123

Author: swift-ci

[refs]

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

trunk/benchmark/utils/DriverUtils.swift

@@ -247,7 +247,7 @@ func stopTrackingObjects(_: UnsafePointer<CChar>) -> Int
 #endif
 
 #if os(Linux)
-class Timer {
+final class Timer {
   typealias TimeT = timespec
   func getTime() -> TimeT {
     var ticks = timespec(tv_sec: 0, tv_nsec: 0)
@@ -267,7 +267,7 @@ class Timer {
   }
 }
 #else
-class Timer {
+final class Timer {
   typealias TimeT = UInt64
   var info = mach_timebase_info_data_t(numer: 0, denom: 0)
   init() {
@@ -283,13 +283,18 @@ class Timer {
 }
 #endif
 
-class SampleRunner {
+final class SampleRunner {
   let timer = Timer()
   let baseline = SampleRunner.getResourceUtilization()
   let c: TestConfig
+  var start, end, lastYield: Timer.TimeT
+  let schedulerQuantum = UInt64(10_000_000) // nanoseconds (== 10ms, macos)
 
   init(_ config: TestConfig) {
     self.c = config
+    sched_yield()
+    let now = timer.getTime()
+    (start, end, lastYield) = (now, now, now)
   }
 
   private static func getResourceUtilization() -> rusage {
@@ -298,39 +303,63 @@ class SampleRunner {
 
   /// Returns maximum resident set size (MAX_RSS) delta in bytes
   func measureMemoryUsage() -> Int {
-      var current = SampleRunner.getResourceUtilization()
-      let maxRSS = current.ru_maxrss - baseline.ru_maxrss
+    let current = SampleRunner.getResourceUtilization()
+    let maxRSS = current.ru_maxrss - baseline.ru_maxrss
 
-      if c.verbose {
-        let pages = maxRSS / sysconf(_SC_PAGESIZE)
-        func deltaEquation(_ stat: KeyPath<rusage, Int>) -> String {
-          let b = baseline[keyPath: stat], c = current[keyPath: stat]
-          return "\(c) - \(b) = \(c - b)"
-        }
-        print("""
-                  MAX_RSS \(deltaEquation(\rusage.ru_maxrss)) (\(pages) pages)
-                  ICS \(deltaEquation(\rusage.ru_nivcsw))
-                  VCS \(deltaEquation(\rusage.ru_nvcsw))
-              """)
+    if c.verbose {
+      let pages = maxRSS / sysconf(_SC_PAGESIZE)
+      func deltaEquation(_ stat: KeyPath<rusage, Int>) -> String {
+        let b = baseline[keyPath: stat], c = current[keyPath: stat]
+        return "\(c) - \(b) = \(c - b)"
       }
-      return maxRSS
+      print("""
+                MAX_RSS \(deltaEquation(\rusage.ru_maxrss)) (\(pages) pages)
+                ICS \(deltaEquation(\rusage.ru_nivcsw))
+                VCS \(deltaEquation(\rusage.ru_nvcsw))
+            """)
+    }
+    return maxRSS
+  }
+
+  private func startMeasurement() {
+    let spent = timer.diffTimeInNanoSeconds(from: lastYield, to: end)
+    let nextSampleEstimate = UInt64(Double(lastSampleTime) * 1.5)
+
+    if (spent + nextSampleEstimate < schedulerQuantum) {
+        start = timer.getTime()
+    } else {
+        if c.verbose {
+          print("    Yielding again after estimated \(spent/1000) us")
+        }
+        sched_yield()
+        let now = timer.getTime()
+        (start, lastYield) = (now, now)
+    }
+  }
+
+  private func stopMeasurement() {
+    end = timer.getTime()
+  }
+
+  /// Time in nanoseconds spent running the last function
+  var lastSampleTime: UInt64 {
+    return timer.diffTimeInNanoSeconds(from: start, to: end)
   }
 
   func run(_ name: String, fn: (Int) -> Void, num_iters: UInt) -> UInt64 {
-    // Start the timer.
 #if SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
     name.withCString { p in startTrackingObjects(p) }
 #endif
-    let start_ticks = timer.getTime()
+
+    self.startMeasurement()
     fn(Int(num_iters))
-    // Stop the timer.
-    let end_ticks = timer.getTime()
+    self.stopMeasurement()
+
 #if SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
     name.withCString { p in stopTrackingObjects(p) }
 #endif
 
-    // Compute the spent time and the scaling factor.
-    return timer.diffTimeInNanoSeconds(from: start_ticks, to: end_ticks)
+    return lastSampleTime
   }
 }
 

trunk/lib/IRGen/LoadableByAddress.cpp

@@ -1491,7 +1491,21 @@ void LoadableStorageAllocation::allocateForArg(SILValue value) {
 
   assert(!ApplySite::isa(value) && "Unexpected instruction");
 
-  SILBuilderWithScope allocBuilder(&*pass.F->begin());
+  // Find the first non-AllocStackInst and use its scope when creating
+  // the new SILBuilder. An AllocStackInst does not directly cause any
+  // code to be generated. The location of an AllocStackInst carries information
+  // about the source variable; it doesn't matter where in the instruction
+  // stream the AllocStackInst is located.
+  auto BBIter = pass.F->begin()->begin();
+  SILInstruction *FirstNonAllocStack = &*BBIter;
+  while (isa<AllocStackInst>(FirstNonAllocStack) &&
+         BBIter != pass.F->begin()->end()) {
+    BBIter++;
+    FirstNonAllocStack = &*BBIter;
+  }
+  SILBuilderWithScope allocBuilder(&*pass.F->begin()->begin(),
+                                   FirstNonAllocStack);
+
   AllocStackInst *allocInstr =
       allocBuilder.createAllocStack(value.getLoc(), value->getType());
 

trunk/lib/Index/Index.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/Expr.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/Types.h"
 #include "swift/AST/USRGeneration.h"
 #include "swift/Basic/SourceManager.h"
@@ -78,6 +79,13 @@ static bool isMemberwiseInit(swift::ValueDecl *D) {
   return false;
 }
 
+static SourceLoc getLocForExtension(ExtensionDecl *D) {
+  // Use the 'End' token of the range, in case it is a compound name, e.g.
+  //   extension A.B {}
+  // we want the location of 'B' token.
+  return D->getExtendedTypeLoc().getSourceRange().End;
+}
+
 namespace {
 // Adapter providing a common interface for a SourceFile/Module.
 class SourceFileOrModule {
@@ -121,6 +129,11 @@ class SourceFileOrModule {
   }
 };
 
+struct ValueWitness {
+  ValueDecl *Member;
+  ValueDecl *Requirement;
+};
+
 class IndexSwiftASTWalker : public SourceEntityWalker {
   IndexDataConsumer &IdxConsumer;
   SourceManager &SrcMgr;
@@ -133,6 +146,7 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
     Decl *D;
     SymbolInfo SymInfo;
     SymbolRoleSet Roles;
+    SmallVector<ValueWitness, 6> ExplicitValueWitnesses;
     SmallVector<SourceLoc, 6> RefsToSuppress;
   };
   SmallVector<Entity, 6> EntitiesStack;
@@ -319,7 +333,7 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
       IndexSymbol Info;
       if (initIndexSymbol(Prop, *LabelIt++, /*IsRef=*/true, Info))
         continue;
-      if (startEntity(Prop, Info))
+      if (startEntity(Prop, Info, /*IsRef=*/true))
         finishCurrentEntity();
     }
   }
@@ -398,8 +412,10 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
   bool reportExtension(ExtensionDecl *D);
   bool reportRef(ValueDecl *D, SourceLoc Loc, IndexSymbol &Info,
                  Optional<AccessKind> AccKind);
+  bool reportImplicitValueConformance(ValueDecl *witness, ValueDecl *requirement,
+                                      Decl *container);
 
-  bool startEntity(Decl *D, IndexSymbol &Info);
+  bool startEntity(Decl *D, IndexSymbol &Info, bool IsRef);
   bool startEntityDecl(ValueDecl *D);
 
   bool reportRelatedRef(ValueDecl *D, SourceLoc Loc, bool isImplicit, SymbolRoleSet Relations, Decl *Related);
@@ -459,6 +475,14 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
     return true;
   }
 
+  /// Reports all implicit member value decl conformances that \p D introduces
+  /// as implicit overrides at the source location of \p D, and returns the
+  /// explicit ones so we can check against them later on when visiting them as
+  /// members.
+  ///
+  /// \returns false if AST visitation should stop.
+  bool handleValueWitnesses(Decl *D, SmallVectorImpl<ValueWitness> &explicitValueWitnesses);
+
   void getModuleHash(SourceFileOrModule SFOrMod, llvm::raw_ostream &OS);
   llvm::hash_code hashModule(llvm::hash_code code, SourceFileOrModule SFOrMod);
   llvm::hash_code hashFileReference(llvm::hash_code code,
@@ -612,16 +636,53 @@ bool IndexSwiftASTWalker::visitImports(
   return true;
 }
 
-bool IndexSwiftASTWalker::startEntity(Decl *D, IndexSymbol &Info) {
+bool IndexSwiftASTWalker::handleValueWitnesses(Decl *D, SmallVectorImpl<ValueWitness> &explicitValueWitnesses) {
+  auto DC = dyn_cast<DeclContext>(D);
+  if (!DC)
+    return true;
+
+  for (auto *conf : DC->getLocalConformances()) {
+    if (conf->isInvalid())
+      continue;
+
+    auto normal = conf->getRootNormalConformance();
+    normal->forEachValueWitness(nullptr,
+                                [&](ValueDecl *req, Witness witness) {
+      if (Cancelled)
+        return;
+
+      auto *decl = witness.getDecl();
+      if (decl->getDeclContext() == DC) {
+        explicitValueWitnesses.push_back(ValueWitness{decl, req});
+      } else {
+        // Report the implicit conformance.
+        reportImplicitValueConformance(decl, req, D);
+      }
+    });
+  }
+
+  if (Cancelled)
+    return false;
+
+  return true;
+}
+
+bool IndexSwiftASTWalker::startEntity(Decl *D, IndexSymbol &Info, bool IsRef) {
   switch (IdxConsumer.startSourceEntity(Info)) {
     case swift::index::IndexDataConsumer::Abort:
       Cancelled = true;
       LLVM_FALLTHROUGH;
     case swift::index::IndexDataConsumer::Skip:
       return false;
-    case swift::index::IndexDataConsumer::Continue:
-      EntitiesStack.push_back({D, Info.symInfo, Info.roles, {}});
+    case swift::index::IndexDataConsumer::Continue: {
+      SmallVector<ValueWitness, 6> explicitValueWitnesses;
+      if (!IsRef) {
+        if (!handleValueWitnesses(D, explicitValueWitnesses))
+          return false;
+      }
+      EntitiesStack.push_back({D, Info.symInfo, Info.roles, std::move(explicitValueWitnesses), {}});
       return true;
+    }
   }
 
   llvm_unreachable("Unhandled IndexDataConsumer in switch.");
@@ -649,12 +710,15 @@ bool IndexSwiftASTWalker::startEntityDecl(ValueDecl *D) {
       return false;
   }
 
-  for (auto Overriden: getOverriddenDecls(D, /*IncludeProtocolReqs=*/!isSystemModule)) {
-    if (addRelation(Info, (SymbolRoleSet) SymbolRole::RelationOverrideOf, Overriden))
-      return false;
+  for (auto Overriden: getOverriddenDecls(D, /*IncludeProtocolReqs=*/false)) {
+    addRelation(Info, (SymbolRoleSet) SymbolRole::RelationOverrideOf, Overriden);
   }
 
   if (auto Parent = getParentDecl()) {
+    for (const ValueWitness &witness : EntitiesStack.back().ExplicitValueWitnesses) {
+      if (witness.Member == D)
+        addRelation(Info, (SymbolRoleSet) SymbolRole::RelationOverrideOf, witness.Requirement);
+    }
     if (auto ParentVD = dyn_cast<ValueDecl>(Parent)) {
       SymbolRoleSet RelationsToParent = (SymbolRoleSet)SymbolRole::RelationChildOf;
       if (Info.symInfo.SubKind == SymbolSubKind::AccessorGetter ||
@@ -673,7 +737,7 @@ bool IndexSwiftASTWalker::startEntityDecl(ValueDecl *D) {
     }
   }
 
-  return startEntity(D, Info);
+  return startEntity(D, Info, /*IsRef=*/false);
 }
 
 bool IndexSwiftASTWalker::reportRelatedRef(ValueDecl *D, SourceLoc Loc, bool isImplicit,
@@ -836,10 +900,7 @@ IndexSwiftASTWalker::getTypeLocAsNominalTypeDecl(const TypeLoc &Ty) {
 }
 
 bool IndexSwiftASTWalker::reportExtension(ExtensionDecl *D) {
-  // Use the 'End' token of the range, in case it is a compound name, e.g.
-  //   extension A.B {}
-  // we want the location of 'B' token.
-  SourceLoc Loc = D->getExtendedTypeLoc().getSourceRange().End;
+  SourceLoc Loc = getLocForExtension(D);
   NominalTypeDecl *NTD = D->getExtendedNominal();
   if (!NTD)
     return true;
@@ -850,7 +911,7 @@ bool IndexSwiftASTWalker::reportExtension(ExtensionDecl *D) {
   if (initIndexSymbol(D, NTD, Loc, Info))
     return true;
 
-  if (!startEntity(D, Info))
+  if (!startEntity(D, Info, /*IsRef=*/false))
     return false;
 
   if (!reportRelatedRef(NTD, Loc, /*isImplicit=*/false,
@@ -940,7 +1001,7 @@ bool IndexSwiftASTWalker::reportRef(ValueDecl *D, SourceLoc Loc,
   if (isSystemModule && !hasUsefulRoleInSystemModule(Info.roles))
     return true;
 
-  if (!startEntity(D, Info))
+  if (!startEntity(D, Info, /*IsRef=*/true))
     return true;
 
   // Report the accessors that were utilized.
@@ -961,6 +1022,34 @@ bool IndexSwiftASTWalker::reportRef(ValueDecl *D, SourceLoc Loc,
   return finishCurrentEntity();
 }
 
+bool IndexSwiftASTWalker::reportImplicitValueConformance(ValueDecl *witness, ValueDecl *requirement,
+                                                         Decl *container) {
+  if (!shouldIndex(witness, /*IsRef=*/true))
+    return true; // keep walking
+
+  SourceLoc loc;
+  if (auto *extD = dyn_cast<ExtensionDecl>(container))
+    loc = getLocForExtension(extD);
+  else
+    loc = container->getLoc();
+
+  IndexSymbol info;
+  if (initIndexSymbol(witness, loc, /*IsRef=*/true, info))
+    return true;
+  if (addRelation(info, (SymbolRoleSet) SymbolRole::RelationOverrideOf, requirement))
+    return true;
+  if (addRelation(info, (SymbolRoleSet) SymbolRole::RelationContainedBy, container))
+    return true;
+  // Remove the 'ref' role that \c initIndexSymbol introduces. This isn't
+  // actually a 'reference', but an 'implicit' override.
+  info.roles &= ~(SymbolRoleSet)SymbolRole::Reference;
+  info.roles |= (SymbolRoleSet)SymbolRole::Implicit;
+
+  if (!startEntity(witness, info, /*IsRef=*/true))
+    return true;
+  return finishCurrentEntity();
+}
+
 bool IndexSwiftASTWalker::initIndexSymbol(ValueDecl *D, SourceLoc Loc,
                                           bool IsRef, IndexSymbol &Info) {
   assert(D);