Add support for the Scudo sanitizer. (#2717)

* Add support for the Scudo sanitizer. + Test sanitizers with build plans

The Swift PR swiftlang/swift#28538 adds support for the Scudo hardened
allocator to swiftc. This patch adds support for it to Swift Package
Manager, allowing the Package Manager to correctly plumb Scudo through
the entire build pipeline.

See the aforementioned PR for more discussion on the value of supporting
Scudo.

(cherry picked from commit 594ccaa)

* Test sanitizers with build plans. (#2720)

The current tests for sanitizers in SwiftPM are essentially "live": they
build a package that will do something to trigger a sanitizer, and then
run it and confirm it fails. This is a pretty fragile way to test, and
it exposes SwiftPM to a number of possible test failures that don't
have anything to do with the core mission (exposing the sanitizer).

This patch replaces those tests with build plan tests that validate that
SwiftPM correctly invokes swiftc and clang. These tests are acceptable
because for now SwiftPM doesn't have any smarts with the sanitizers: it
just passes them all through to swiftc and clang.

This patch also deletes the current live tests, as they are no longer
necessary.

(cherry picked from commit 984618b)

Author: Lukasa

Fixtures/Miscellaneous/ThreadRace/.gitignore

@@ -16,13 +16,15 @@ public enum Sanitizer: String, Encodable {
     case address
     case thread
     case undefined
+    case scudo
 
     /// 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"
             case .undefined: return "ubsan"
+            case .scudo: return "scudo"
         }
     }
 }
@@ -72,6 +74,7 @@ extension Sanitizer: StringEnumArgument {
     public static let completion: ShellCompletion = .values([
         (address.rawValue, "enable Address sanitizer"),
         (thread.rawValue, "enable Thread sanitizer"),
-        (undefined.rawValue, "enable Undefined Behavior sanitizer")
+        (undefined.rawValue, "enable Undefined Behavior sanitizer"),
+        (scudo.rawValue, "enable Scudo hardened allocator")
     ])
 }

Fixtures/Miscellaneous/ThreadRace/Package.swift

@@ -2342,6 +2342,73 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertMatch(clibraryLinkArguments, [.anySequence, "-L", "/path/to/build/debug", .anySequence])
         XCTAssertMatch(clibraryLinkArguments, ["-lStaticLibrary"])
     }
+
+    func testAddressSanitizer() throws {
+        try sanitizerTest(.address, expectedName: "address")
+    }
+
+    func testThreadSanitizer() throws {
+        try sanitizerTest(.thread, expectedName: "thread")
+    }
+
+    func testUndefinedSanitizer() throws {
+        try sanitizerTest(.undefined, expectedName: "undefined")
+    }
+
+    func testScudoSanitizer() throws {
+        try sanitizerTest(.scudo, expectedName: "scudo")
+    }
+
+    private func sanitizerTest(_ sanitizer: Sanitizer, expectedName: String) throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Pkg/Sources/exe/main.swift",
+            "/Pkg/Sources/lib/lib.swift",
+            "/Pkg/Sources/clib/clib.c",
+            "/Pkg/Sources/clib/include/clib.h"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        let graph = loadPackageGraph(fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Pkg",
+                    path: "/Pkg",
+                    url: "/Pkg",
+                    packageKind: .root,
+                    targets: [
+                        TargetDescription(name: "exe", dependencies: ["lib", "clib"]),
+                        TargetDescription(name: "lib", dependencies: []),
+                        TargetDescription(name: "clib", dependencies: []),
+                    ]),
+            ]
+        )
+        XCTAssertNoDiagnostics(diagnostics)
+
+        // Unrealistic: we can't enable all of these at once on all platforms.
+        // This test codifies current behaviour, not ideal behaviour, and
+        // may need to be amended if we change it.
+        var parameters = mockBuildParameters(shouldLinkStaticSwiftStdlib: true)
+        parameters.sanitizers = EnabledSanitizers([sanitizer])
+
+        let result = BuildPlanResult(plan: try BuildPlan(
+            buildParameters: parameters,
+            graph: graph, diagnostics: diagnostics, fileSystem: fs)
+        )
+
+        result.checkProductsCount(1)
+        result.checkTargetsCount(3)
+
+        let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+        XCTAssertTrue(exe.contains("-sanitize=\(expectedName)"))
+
+        let lib = try result.target(for: "lib").swiftTarget().compileArguments()
+        XCTAssertTrue(lib.contains("-sanitize=\(expectedName)"))
+
+        let clib  = try result.target(for: "clib").clangTarget().basicArguments()
+        XCTAssertTrue(clib.contains("-fsanitize=\(expectedName)"))
+
+        XCTAssertTrue(try result.buildProduct(for: "exe").linkArguments().contains("-sanitize=\(expectedName)"))
+    }
 }
 
 // MARK:- Test Helpers

Fixtures/Miscellaneous/ThreadRace/README.md

@@ -103,29 +103,4 @@ final class RunToolTests: XCTestCase {
             }
         }
     }
-
-    // Test that thread sanitizer works.
-    func testSanitizeThread() throws {
-        // FIXME: We need to figure out how to test this for linux.
-      #if os(macOS)
-        fixture(name: "Miscellaneous/ThreadRace") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let env = ["TSAN_OPTIONS": "abort_on_error=0"]
-            let cmdline = {
-                try SwiftPMProduct.SwiftRun.execute(
-                    ["--sanitize=thread"], packagePath: path, env: env)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("ThreadSanitizer: data race"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
 }

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

@@ -30,32 +30,6 @@ final class TestToolTests: XCTestCase {
         XCTAssert(try execute(["--version"]).stdout.contains("Swift Package Manager"))
     }
 
-    // Test that thread sanitizer works.
-    func testSanitizeThread() throws {
-        // FIXME: We need to figure out how to test this for linux.
-        // Disabled because of https://bugs.swift.org/browse/SR-7272
-      #if false
-        fixture(name: "Miscellaneous/ThreadRace") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let env = ["TSAN_OPTIONS": "abort_on_error=0"]
-            let cmdline = {
-                try SwiftPMProduct.SwiftTest.execute(
-                    ["--sanitize=thread"], packagePath: path, env: env)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("ThreadSanitizer: data race"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
-    
     func testNumWorkersParallelRequeriment() throws {
         // Running swift-test fixtures on linux is not yet possible.
         #if os(macOS)