Add support for the Scudo sanitizer.

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.

Author: Lukasa

Fixtures/Miscellaneous/DoubleFree/Package.swift

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

Fixtures/Miscellaneous/DoubleFree/README.md

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

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

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

Fixtures/Miscellaneous/DoubleFree/Sources/lib/lib.swift

@@ -0,0 +1,9 @@
+public func executeDoubleFree() {
+    let size = 512
+
+    let buffer = UnsafeMutableRawBufferPointer.allocate(byteCount: size, alignment: 1)
+    buffer[0] = 0
+    buffer.deallocate()
+    buffer.deallocate()
+    print(buffer[0])
+}

Fixtures/Miscellaneous/DoubleFree/Tests/LinuxMain.swift

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

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

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

Fixtures/Miscellaneous/DoubleFree/Tests/libTests/libTests.swift

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

Sources/Build/Sanitizers.swift

@@ -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")
     ])
 }

Tests/CommandsTests/RunToolTests.swift

@@ -127,4 +127,27 @@ final class RunToolTests: XCTestCase {
         }
       #endif
     }
+
+    func testSanitizeScudo() throws {
+        // Scudo is only supported on Linux.
+      #if os(Linux)
+        fixture(name: "Miscellaneous/DoubleFree") { path in
+            // Ensure that we don't abort() when we find the race. This avoids
+            // generating the crash report on macOS.
+            let cmdline = {
+                try SwiftPMProduct.SwiftRun.execute(
+                    ["--sanitize=scudo"], packagePath: path)
+            }
+            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
+                switch error {
+                case .executionFailure(_, _, let error):
+                    XCTAssertMatch(error, .contains("invalid chunk state"))
+                    return true
+                default:
+                    return false
+                }
+            }
+        }
+      #endif
+    }
 }

Tests/CommandsTests/TestToolTests.swift

@@ -80,4 +80,25 @@ final class TestToolTests: XCTestCase {
         }
         #endif
     }
+
+    func testSanitizeScudo() throws {
+        // This test only runs on Linux because Scudo only runs on Linux
+      #if os(Linux)
+        fixture(name: "Miscellaneous/ThreadRace") { path in
+            let cmdline = {
+                try SwiftPMProduct.SwiftTest.execute(
+                    ["--sanitize=scudo"], packagePath: path)
+            }
+            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
+                switch error {
+                case .executionFailure(_, _, let error):
+                    XCTAssertMatch(error, .contains("invalid chunk state"))
+                    return true
+                default:
+                    return false
+                }
+            }
+        }
+      #endif
+    }
 }

Tests/CommandsTests/XCTestManifests.swift

@@ -61,6 +61,7 @@ extension RunToolTests {
         ("testFileDeprecation", testFileDeprecation),
         ("testMultipleExecutableAndExplicitExecutable", testMultipleExecutableAndExplicitExecutable),
         ("testMutualExclusiveFlags", testMutualExclusiveFlags),
+        ("testSanitizeScudo", testSanitizeScudo),
         ("testSanitizeThread", testSanitizeThread),
         ("testSeeAlso", testSeeAlso),
         ("testUnkownProductAndArgumentPassing", testUnkownProductAndArgumentPassing),
@@ -77,6 +78,7 @@ extension TestToolTests {
     static let __allTests__TestToolTests = [
         ("testNumWorkersParallelRequeriment", testNumWorkersParallelRequeriment),
         ("testNumWorkersValue", testNumWorkersValue),
+        ("testSanitizeScudo", testSanitizeScudo),
         ("testSanitizeThread", testSanitizeThread),
         ("testSeeAlso", testSeeAlso),
         ("testUsage", testUsage),