---

yaml
---
r: 347461
b: refs/heads/master
c: e628898
h: refs/heads/master
i:
  347459: 0c9684b

Author: swift-ci

[refs]

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

trunk/benchmark/utils/build_script_helper.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import argparse
+import os
+import subprocess
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--verbose', '-v', action='store_true')
+    parser.add_argument('--package-path', type=str, required=True)
+    parser.add_argument('--build-path', type=str, required=True)
+    parser.add_argument('--toolchain', type=str, required=True)
+
+    # Build the debug/release versions.
+    args = parser.parse_args()
+    swiftbuild_path = os.path.join(args.toolchain, 'usr', 'bin', 'swift-build')
+    swiftbuild_args = [
+        swiftbuild_path,
+        '--package-path', args.package_path,
+        '--build-path', args.build_path,
+        '--configuration', 'debug',
+    ]
+    if args.verbose:
+        swiftbuild_args.append('--verbose')
+    subprocess.call(swiftbuild_args)
+
+    swiftbuild_args = [
+        swiftbuild_path,
+        '--package-path', args.package_path,
+        '--build-path', args.build_path,
+        '--configuration', 'release',
+        '-Xswiftc', '-Xllvm',
+        '-Xswiftc', '-align-module-to-page-size',
+    ]
+    if args.verbose:
+        swiftbuild_args.append('--verbose')
+    subprocess.call(swiftbuild_args)
+
+
+if __name__ == "__main__":
+    main()

trunk/lib/Frontend/ParseableInterfaceModuleLoader.cpp

@@ -247,6 +247,32 @@ static Optional<llvm::vfs::Status> getStatusOfDependency(
   return status.get();
 }
 
+/// If the file dependency in \p FullDepPath is inside the \p Base directory,
+/// this returns its path relative to \p Base. Otherwise it returns None.
+static Optional<StringRef> getRelativeDepPath(StringRef DepPath,
+                                              StringRef Base) {
+  // If Base is the root directory, or DepPath does not start with Base, bail.
+  if (Base.size() <= 1 || !DepPath.startswith(Base)) {
+    return None;
+  }
+
+  assert(DepPath.size() > Base.size() &&
+      "should never depend on a directory");
+
+  // Is the DepName something like ${Base}/foo.h"?
+  if (path::is_separator(DepPath[Base.size()]))
+    return DepPath.substr(Base.size() + 1);
+
+  // Is the DepName something like "${Base}foo.h", where Base
+  // itself contains a trailing slash?
+  if (path::is_separator(Base.back()))
+    return DepPath.substr(Base.size());
+
+  // We have something next to Base, like "Base.h", that's somehow
+  // become a dependency.
+  return None;
+}
+
 #pragma mark - Module Building
 
 /// Builds a parseable module interface into a .swiftmodule at the provided
@@ -365,52 +391,29 @@ class swift::ParseableInterfaceBuilder {
   bool collectDepsForSerialization(CompilerInstance &SubInstance,
                                    SmallVectorImpl<FileDependency> &Deps,
                                    bool IsHashBased) {
-    StringRef SDKPath = SubInstance.getASTContext().SearchPathOpts.SDKPath;
-    StringRef ResourcePath =
-        SubInstance.getASTContext().SearchPathOpts.RuntimeResourcePath;
+    auto &Opts = SubInstance.getASTContext().SearchPathOpts;
+    SmallString<128> SDKPath(Opts.SDKPath);
+    path::native(SDKPath);
+    SmallString<128> ResourcePath(Opts.RuntimeResourcePath);
+    path::native(ResourcePath);
+
     auto DTDeps = SubInstance.getDependencyTracker()->getDependencies();
     SmallVector<StringRef, 16> InitialDepNames(DTDeps.begin(), DTDeps.end());
     InitialDepNames.push_back(interfacePath);
     llvm::StringSet<> AllDepNames;
+    SmallString<128> Scratch;
+
+    for (const auto &InitialDepName : InitialDepNames) {
+      path::native(InitialDepName, Scratch);
+      StringRef DepName = Scratch.str();
 
-    for (auto const &DepName : InitialDepNames) {
       assert(moduleCachePath.empty() || !DepName.startswith(moduleCachePath));
       assert(prebuiltCachePath.empty() || !DepName.startswith(prebuiltCachePath));
 
-      /// Lazily load the dependency buffer if we need it. If we're not
-      /// dealing with a hash-based dependencies, and if the dependency is
-      /// not a .swiftmodule, we can avoid opening the buffer.
-      std::unique_ptr<llvm::MemoryBuffer> DepBuf = nullptr;
-      auto getDepBuf = [&]() -> llvm::MemoryBuffer * {
-        if (DepBuf) return DepBuf.get();
-        if (auto Buf = getBufferOfDependency(fs, DepName, interfacePath,
-                                             diags, diagnosticLoc)) {
-          DepBuf = std::move(Buf);
-          return DepBuf.get();
-        }
-        return nullptr;
-      };
-
-      // Adjust the paths of dependences in the SDK to be relative to it
-      bool IsSDKRelative = false;
-      StringRef DepNameToStore = DepName;
-      if (SDKPath.size() > 1 && DepName.startswith(SDKPath)) {
-        assert(DepName.size() > SDKPath.size() &&
-            "should never depend on a directory");
-        if (llvm::sys::path::is_separator(DepName[SDKPath.size()])) {
-          // Is the DepName something like ${SDKPath}/foo.h"?
-          DepNameToStore = DepName.substr(SDKPath.size() + 1);
-          IsSDKRelative = true;
-        } else if (llvm::sys::path::is_separator(SDKPath.back())) {
-          // Is the DepName something like "${SDKPath}foo.h", where SDKPath
-          // itself contains a trailing slash?
-          DepNameToStore = DepName.substr(SDKPath.size());
-          IsSDKRelative = true;
-        } else {
-          // We have something next to an SDK, like "Foo.sdk.h", that's somehow
-          // become a dependency.
-        }
-      }
+      // Serialize the paths of dependencies in the SDK relative to it.
+      Optional<StringRef> SDKRelativePath = getRelativeDepPath(DepName, SDKPath);
+      StringRef DepNameToStore = SDKRelativePath.getValueOr(DepName);
+      bool IsSDKRelative = SDKRelativePath.hasValue();
 
       if (AllDepNames.insert(DepName).second && dependencyTracker) {
         dependencyTracker->addDependency(DepName, /*isSystem*/IsSDKRelative);
@@ -425,6 +428,20 @@ class swift::ParseableInterfaceBuilder {
       if (!Status)
         return true;
 
+      /// Lazily load the dependency buffer if we need it. If we're not
+      /// dealing with a hash-based dependencies, and if the dependency is
+      /// not a .swiftmodule, we can avoid opening the buffer.
+      std::unique_ptr<llvm::MemoryBuffer> DepBuf = nullptr;
+      auto getDepBuf = [&]() -> llvm::MemoryBuffer * {
+        if (DepBuf) return DepBuf.get();
+        if (auto Buf = getBufferOfDependency(fs, DepName, interfacePath,
+                                             diags, diagnosticLoc)) {
+          DepBuf = std::move(Buf);
+          return DepBuf.get();
+        }
+        return nullptr;
+      };
+
       if (IsHashBased) {
         auto buf = getDepBuf();
         if (!buf) return true;
@@ -687,8 +704,7 @@ class ParseableInterfaceModuleLoaderImpl {
     if (!dep.isSDKRelative())
       return dep.getPath();
 
-    StringRef SDKPath = ctx.SearchPathOpts.SDKPath;
-    scratch.assign(SDKPath.begin(), SDKPath.end());
+    path::native(ctx.SearchPathOpts.SDKPath, scratch);
     llvm::sys::path::append(scratch, dep.getPath());
     return StringRef(scratch.data(), scratch.size());
   }
@@ -1003,7 +1019,8 @@ class ParseableInterfaceModuleLoaderImpl {
         SmallString<128> SDKRelativeBuffer;
         for (auto &dep: allDeps) {
           StringRef fullPath = getFullDependencyPath(dep, SDKRelativeBuffer);
-          dependencyTracker->addDependency(fullPath, dep.isSDKRelative());
+          dependencyTracker->addDependency(fullPath,
+                                           /*IsSystem=*/dep.isSDKRelative());
         }
       }
 

trunk/utils/build-script

@@ -244,11 +244,17 @@ class BuildScriptInvocation(object):
                     "--android-icu-i18n-include, and --android-icu-data "
                     "must be specified")
 
-        if args.legacy_impl and (args.build_indexstoredb or
-                                 args.build_sourcekitlsp):
+        targets_needing_toolchain = [
+            'build_indexstoredb',
+            'build_sourcekitlsp',
+            'build_toolchainbenchmarks',
+        ]
+        has_target_needing_toolchain = \
+            bool(sum(getattr(args, x) for x in targets_needing_toolchain))
+        if args.legacy_impl and has_target_needing_toolchain:
             diagnostics.fatal(
                 "--legacy-impl is incompatible with building packages needing "
-                "a toolchain (indexstore-db or sourcekit-lsp)")
+                "a toolchain (%s)" % ", ".join(targets_needing_toolchain))
 
     @staticmethod
     def apply_default_arguments(toolchain, args):
@@ -879,6 +885,8 @@ class BuildScriptInvocation(object):
             product_classes.append(products.IndexStoreDB)
         if self.args.build_sourcekitlsp:
             product_classes.append(products.SourceKitLSP)
+        if self.args.build_toolchainbenchmarks:
+            product_classes.append(products.ToolchainBenchmarks)
         return product_classes
 
     def execute(self):

trunk/utils/build_swift/driver_arguments.py

@@ -546,6 +546,10 @@ def create_argument_parser():
            help='build IndexStoreDB')
     option(['--sourcekit-lsp'], toggle_true('build_sourcekitlsp'),
            help='build SourceKitLSP')
+    option(['--toolchain-benchmarks'],
+           toggle_true('build_toolchainbenchmarks'),
+           help='build Swift Benchmarks using swiftpm against the just built '
+                'toolchain')
 
     option('--xctest', toggle_true('build_xctest'),
            help='build xctest')

trunk/utils/build_swift/tests/expected_options.py

@@ -88,6 +88,7 @@
     'build_swiftevolve': False,
     'build_indexstoredb': False,
     'build_sourcekitlsp': False,
+    'build_toolchainbenchmarks': False,
     'build_tvos': True,
     'build_tvos_device': False,
     'build_tvos_simulator': False,
@@ -448,6 +449,7 @@ class IgnoreOption(_BaseOption):
     EnableOption('--libicu', dest='build_libicu'),
     EnableOption('--indexstore-db', dest='build_indexstoredb'),
     EnableOption('--sourcekit-lsp', dest='build_sourcekitlsp'),
+    EnableOption('--toolchain-benchmarks', dest='build_toolchainbenchmarks'),
     EnableOption('--long-test'),
     EnableOption('--show-sdks'),
     EnableOption('--stress-test'),

trunk/utils/swift_build_support/swift_build_support/products/__init__.py

@@ -10,6 +10,7 @@
 #
 # ----------------------------------------------------------------------------
 
+from .benchmarks import ToolchainBenchmarks
 from .cmark import CMark
 from .foundation import Foundation
 from .indexstoredb import IndexStoreDB
@@ -47,4 +48,5 @@
     'SwiftEvolve',
     'IndexStoreDB',
     'SourceKitLSP',
+    'ToolchainBenchmarks',
 ]

trunk/utils/swift_build_support/swift_build_support/products/benchmarks.py

@@ -0,0 +1,71 @@
+# swift_build_support/products/benchmarks.py --------------------*- python -*-
+#
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+# Licensed under Apache License v2.0 with Runtime Library Exception
+#
+# See https://swift.org/LICENSE.txt for license information
+# See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+#
+# ----------------------------------------------------------------------------
+
+import os
+import platform
+
+from . import product
+from .. import shell
+from .. import targets
+
+
+# Build against the current installed toolchain.
+class ToolchainBenchmarks(product.Product):
+    @classmethod
+    def product_source_name(cls):
+        return "benchmarks"
+
+    @classmethod
+    def is_build_script_impl_product(cls):
+        return False
+
+    def do_build(self, host_target):
+        run_build_script_helper(host_target, self, self.args)
+
+    def do_test(self, host_target):
+        """Just run a single instance of the command for both .debug and
+           .release.
+        """
+        cmdline = ['--num-iters=1', 'XorLoop']
+        debug_bench = os.path.join(self.build_dir, 'debug', 'SwiftBench')
+        shell.call([debug_bench] + cmdline)
+
+        release_bench = os.path.join(self.build_dir, 'release', 'SwiftBench')
+        shell.call([release_bench] + cmdline)
+
+
+def run_build_script_helper(host_target, product, args):
+    toolchain_path = args.install_destdir
+    if platform.system() == 'Darwin':
+        # The prefix is an absolute path, so concatenate without os.path.
+        toolchain_path += \
+            targets.darwin_toolchain_prefix(args.install_prefix)
+
+    # Our source_dir is expected to be './$SOURCE_ROOT/benchmarks'. That is due
+    # the assumption that each product is in its own build directory. This
+    # product is not like that and has its package/tools instead in
+    # ./$SOURCE_ROOT/swift/benchmark.
+    package_path = os.path.join(product.source_dir, '..', 'swift', 'benchmark')
+    package_path = os.path.abspath(package_path)
+
+    # We use a separate python helper to enable quicker iteration when working
+    # on this by avoiding going through build-script to test small changes.
+    helper_path = os.path.join(package_path, 'utils', 'build_script_helper.py')
+
+    build_cmd = [
+        helper_path,
+        '--verbose',
+        '--package-path', package_path,
+        '--build-path', product.build_dir,
+        '--toolchain', toolchain_path,
+    ]
+    shell.call(build_cmd)