Add thread sanitizer support

Author: vlm

Fixtures/Miscellaneous/ThreadRace/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj

Fixtures/Miscellaneous/ThreadRace/Package.swift

@@ -0,0 +1,18 @@
+// swift-tools-version:4.0
+
+import PackageDescription
+
+let package = Package(
+    name: "race",
+    targets: [
+        .target(
+            name: "lib",
+            dependencies: []),
+        .target(
+            name: "exec",
+            dependencies: ["lib"]),
+        .testTarget(
+            name: "libTests",
+            dependencies: ["lib"]),
+    ]
+)

Fixtures/Miscellaneous/ThreadRace/README.md

@@ -0,0 +1,3 @@
+# race
+
+A description of this package.

Fixtures/Miscellaneous/ThreadRace/Sources/exec/main.swift

@@ -0,0 +1,3 @@
+import lib
+
+executeRace()

Fixtures/Miscellaneous/ThreadRace/Sources/lib/lib.swift

@@ -0,0 +1,16 @@
+import Dispatch
+
+public func executeRace() {
+    var global = 5
+
+    let sema = DispatchSemaphore(value: 0)
+    DispatchQueue.global().async {
+        global = 6
+        sema.signal()
+    }
+
+    global = 7
+    sema.wait()
+
+    print(global)
+}

Fixtures/Miscellaneous/ThreadRace/Tests/LinuxMain.swift

@@ -0,0 +1,8 @@
+import XCTest
+
+import libTests
+
+var tests = [XCTestCaseEntry]()
+tests += libTests.__allTests()
+
+XCTMain(tests)

Fixtures/Miscellaneous/ThreadRace/Tests/libTests/XCTestManifests.swift

@@ -0,0 +1,15 @@
+import XCTest
+
+extension libTests {
+    static let __allTests = [
+        ("testRace", testRace),
+    ]
+}
+
+#if !os(macOS)
+public func __allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(libTests.__allTests),
+    ]
+}
+#endif

Fixtures/Miscellaneous/ThreadRace/Tests/libTests/libTests.swift

@@ -0,0 +1,8 @@
+import XCTest
+import lib
+
+final class libTests: XCTestCase {
+    func testRace() {
+        executeRace()
+    }
+}

Sources/Build/BuildPlan.swift

@@ -72,6 +72,9 @@ public struct BuildParameters {
     /// If should link the Swift stdlib statically.
     public let shouldLinkStaticSwiftStdlib: Bool
 
+    /// Which compiler sanitizers should be enabled
+    public let sanitizers: EnabledSanitizers
+
     /// If should enable llbuild manifest caching.
     public let shouldEnableManifestCaching: Bool
 
@@ -99,7 +102,8 @@ public struct BuildParameters {
         flags: BuildFlags,
         toolsVersion: ToolsVersion = ToolsVersion.currentToolsVersion,
         shouldLinkStaticSwiftStdlib: Bool = false,
-        shouldEnableManifestCaching: Bool = false
+        shouldEnableManifestCaching: Bool = false,
+        sanitizers: EnabledSanitizers = EnabledSanitizers()
     ) {
         self.dataPath = dataPath
         self.configuration = configuration
@@ -109,6 +113,7 @@ public struct BuildParameters {
         self.toolsVersion = toolsVersion
         self.shouldLinkStaticSwiftStdlib = shouldLinkStaticSwiftStdlib
         self.shouldEnableManifestCaching = shouldEnableManifestCaching
+        self.sanitizers = sanitizers
     }
 }
 
@@ -210,6 +215,7 @@ public final class ClangTargetDescription {
         args += ["-I", clangTarget.includeDir.asString]
         args += additionalFlags
         args += moduleCacheArgs
+        args += buildParameters.sanitizers.compileCFlags()
 
         // User arguments (from -Xcc and -Xcxx below) should follow generated arguments to allow user overrides
         args += buildParameters.flags.cCompilerFlags
@@ -323,6 +329,7 @@ public final class SwiftTargetDescription {
         args += activeCompilationConditions
         args += additionalFlags
         args += moduleCacheArgs
+        args += buildParameters.sanitizers.compileSwiftFlags()
 
         // Add arguments to colorize output if stdout is tty
         if buildParameters.isTTY {
@@ -434,6 +441,7 @@ public final class ProductBuildDescription {
     public func linkArguments() -> [String] {
         var args = [buildParameters.toolchain.swiftCompiler.asString]
         args += buildParameters.toolchain.extraSwiftCFlags
+        args += buildParameters.sanitizers.linkSwiftFlags()
         args += additionalFlags
 
         if buildParameters.configuration == .debug {

Sources/Build/Sanitizers.swift

@@ -0,0 +1,65 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2018 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+import Basic
+import Utility
+
+/// Available runtime sanitizers.
+public enum Sanitizer: String {
+    case address
+    case thread
+
+    /// Return an established short name for a sanitizer, e.g. "asan".
+    public var shortName: String {
+        switch self {
+            case .address: return "asan"
+            case .thread: return "tsan"
+        }
+    }
+}
+
+/// A set of enabled runtime sanitizers.
+public struct EnabledSanitizers {
+    /// A set of enabled sanitizers.
+    public let sanitizers: Set<Sanitizer>
+
+    public init(_ sanitizers: Set<Sanitizer> = []) {
+        // FIXME: We need to throw from here if given sanitizers can't be
+        // enabled.  For e.g., it is illegal to enable thread and address
+        // sanitizers together.
+        self.sanitizers = sanitizers
+    }
+
+    /// Sanitization flags for the C family compiler (C/C++).
+    public func compileCFlags() -> [String] {
+        return sanitizers.map({ "-fsanitize=\($0.rawValue)" })
+    }
+
+    /// Sanitization flags for the Swift compiler.
+    public func compileSwiftFlags() -> [String] {
+        return sanitizers.map({ "-sanitize=\($0.rawValue)" })
+    }
+
+    /// Sanitization flags for the Swift linker and compiler are the same so far.
+    public func linkSwiftFlags() -> [String] {
+        return compileSwiftFlags()
+    }
+
+    public var isEmpty: Bool {
+        return sanitizers.isEmpty
+    }
+}
+
+extension Sanitizer: StringEnumArgument {
+    public static let completion: ShellCompletion = .values([
+        (address.rawValue, "enable Address sanitizer"),
+        (thread.rawValue, "enable Thread sanitizer"),
+    ])
+}

Sources/Commands/Options.swift

@@ -52,5 +52,8 @@ public class ToolOptions {
     /// Skip updating dependencies from their remote during a resolution.
     public var skipDependencyUpdate = false
 
+    /// Which compile-time sanitizers should be enabled.
+    public var sanitizers = EnabledSanitizers()
+
     public required init() {}
 }