---

yaml
---
r: 345073
b: refs/heads/master
c: b2cb64c
h: refs/heads/master
i:
  345071: 276a87a

Author: swift-ci

[refs]

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

trunk/include/swift/Basic/ExponentialGrowthAppendingBinaryByteStream.h

@@ -59,10 +59,10 @@ class ExponentialGrowthAppendingBinaryByteStream
 
   /// This is an optimized version of \c writeBytes that assumes we know the
   /// size of \p Value at compile time (which in particular holds for integers).
-  /// It does so by avoiding the memcopy that \c writeBytes requires to copy
-  /// the arbitrarily sized Buffer to the output buffer and using a direct
-  /// memory assignment instead.
-  /// This assumes that the enianess of this steam is the same as the native
+  /// It does so by exposing the memcpy to the optimizer along with the size 
+  /// of the value being assigned; the compiler can then optimize the memcpy
+  /// into a fixed set of instructions.
+  /// This assumes that the endianess of this steam is the same as the native
   /// endianess on the executing machine. No endianess transformations are
   /// performed.
   template<typename T>
@@ -77,7 +77,7 @@ class ExponentialGrowthAppendingBinaryByteStream
       Data.resize(RequiredSize);
     }
 
-    *(T *)(Data.data() + Offset) = Value;
+    ::memcpy(Data.data() + Offset, &Value, sizeof Value);
 
     return llvm::Error::success();
   }

trunk/include/swift/SIL/SILBuilder.h

@@ -264,6 +264,7 @@ class SILBuilder {
   /// setInsertionPoint - Set the insertion point to insert before the specified
   /// instruction.
   void setInsertionPoint(SILInstruction *I) {
+    assert(I && "can't set insertion point to a null instruction");
     setInsertionPoint(I->getParent(), I->getIterator());
   }
 
@@ -276,6 +277,7 @@ class SILBuilder {
   /// setInsertionPoint - Set the insertion point to insert at the end of the
   /// specified block.
   void setInsertionPoint(SILBasicBlock *BB) {
+    assert(BB && "can't set insertion point to a null basic block");
     setInsertionPoint(BB, BB->end());
   }
 
@@ -2202,7 +2204,9 @@ class SavedInsertionPointRAII {
   SavedInsertionPointRAII &operator=(SavedInsertionPointRAII &&) = delete;
 
   ~SavedInsertionPointRAII() {
-    if (SavedIP.is<SILInstruction *>()) {
+    if (SavedIP.isNull()) {
+      Builder.clearInsertionPoint();
+    } else if (SavedIP.is<SILInstruction *>()) {
       Builder.setInsertionPoint(SavedIP.get<SILInstruction *>());
     } else {
       Builder.setInsertionPoint(SavedIP.get<SILBasicBlock *>());

trunk/lib/IDE/CodeCompletion.cpp

@@ -1598,7 +1598,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   Type ExprType;
 
   /// Whether the expr is of statically inferred metatype.
-  bool IsStaticMetatype;
+  bool IsStaticMetatype = false;
 
   /// User-provided base type for LookupKind::Type completions.
   Type BaseType;

trunk/lib/Index/Index.cpp

@@ -395,7 +395,7 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
 
   Expr *getContainingExpr(size_t index) const {
     if (ExprStack.size() > index)
-      return ExprStack.end()[-(index + 1)];
+      return ExprStack.end()[-std::ptrdiff_t(index + 1)];
     return nullptr;
   }
 

trunk/lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -109,9 +109,15 @@ class SILPerformanceInliner {
     /// increasing the code size.
     TrivialFunctionThreshold = 18,
 
-    /// Configuration for the "soft" caller block limit.
+    /// Configuration for the "soft" caller block limit. When changing, make sure
+    /// you update BlockLimitMaxIntNumerator.
     BlockLimitDenominator = 3000,
 
+    /// Computations with BlockLimitDenominator will overflow with numerators
+    /// >= this value. This equals cbrt(INT_MAX) * cbrt(BlockLimitDenominator);
+    /// we hardcode its value because std::cbrt() is not constexpr.
+    BlockLimitMaxIntNumerator = 18608,
+
     /// No inlining is done if the caller has more than this number of blocks.
     OverallCallerBlockLimit = 400,
 
@@ -418,10 +424,13 @@ bool SILPerformanceInliner::isProfitableToInline(
   // We reduce the benefit if the caller is too large. For this we use a
   // cubic function on the number of caller blocks. This starts to prevent
   // inlining at about 800 - 1000 caller blocks.
-  int blockMinus =
-    (NumCallerBlocks * NumCallerBlocks) / BlockLimitDenominator *
-                        NumCallerBlocks / BlockLimitDenominator;
-  Benefit -= blockMinus;
+  if (NumCallerBlocks < BlockLimitMaxIntNumerator)
+    Benefit -= 
+      (NumCallerBlocks * NumCallerBlocks) / BlockLimitDenominator *
+                          NumCallerBlocks / BlockLimitDenominator;
+  else
+    // The calculation in the if branch would overflow if we performed it.
+    Benefit = 0;
 
   // If we have profile info - use it for final inlining decision.
   auto *bb = AI.getInstruction()->getParent();

trunk/lib/SILOptimizer/Utils/Generics.cpp

@@ -730,8 +730,13 @@ ReabstractionInfo::createSubstitutedType(SILFunction *OrigF,
     // FIXME: Some of the added new requirements may not have been taken into
     // account by the substGenericArgs. So, canonicalize in the context of the
     // specialized signature.
-    FnTy = cast<SILFunctionType>(
-        CanSpecializedGenericSig->getCanonicalTypeInContext(FnTy));
+    if (CanSpecializedGenericSig)
+      FnTy = cast<SILFunctionType>(
+          CanSpecializedGenericSig->getCanonicalTypeInContext(FnTy));
+    else {
+      FnTy = cast<SILFunctionType>(FnTy->getCanonicalType());
+      assert(!FnTy->hasTypeParameter() && "Type parameters outside generic context?");
+    }
   }
   assert(FnTy);
 

trunk/lib/Sema/TypeCheckCaptures.cpp

@@ -719,7 +719,8 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
                           DynamicSelfCaptureLoc,
                           DynamicSelf,
                           AFR);
-  AFR.getBody()->walk(finder);
+  if (AFR.getBody())
+    AFR.getBody()->walk(finder);
 
   unsigned inoutCount = 0;
   for (auto C : Captures) {

trunk/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp

@@ -873,7 +873,8 @@ static bool passCursorInfoForDecl(SourceFile* SF,
   auto ClangNode = VD->getClangNode();
   if (ClangNode) {
     auto ClangMod = Importer->getClangOwningModule(ClangNode);
-    ModuleName = ClangMod->getFullModuleName();
+    if (ClangMod)
+      ModuleName = ClangMod->getFullModuleName();
   } else if (VD->getLoc().isInvalid() && VD->getModuleContext() != MainModule) {
     ModuleName = VD->getModuleContext()->getName().str();
   }

trunk/tools/SourceKit/tools/sourcekitd/include/sourcekitd/CompactArray.h

@@ -102,7 +102,9 @@ class CompactArrayReaderImpl {
   CompactArrayReaderImpl(void *Buf) : Buf(Buf) {}
 
   uint64_t getEntriesBufSize() const {
-    return *(uint64_t*)Buf;
+    uint64_t result;
+    std::memcpy(&result, Buf, sizeof result);
+    return result;
   }
   const uint8_t *getEntriesBufStart() const {
     return (const uint8_t *)(((uint64_t*)Buf)+1);