Update Options.swift

Author: chiragramani

Sources/SwiftDriver/Driver/Driver.swift

@@ -3341,21 +3341,25 @@ extension Driver {
     let genFlags: [Option] = [
       .profileGenerate,
       .irProfileGenerate,
+      .irProfileGenerateEQ,
       .csProfileGenerate,
-      .csProfileGenerateEq,
+      .csProfileGenerateEQ,
     ]
+    func resolveDualFormConflict(_ plain: Option, _ equalsForm: Option) {
+       if parsedOptions.hasArgument(plain),
+          parsedOptions.hasArgument(equalsForm)
+       {
+         diagnosticEngine.emit(
+           .error(Error.conflictingOptions(plain, equalsForm)),
+           location: nil
+         )
+         providedGen.removeAll { $0 == equalsForm }
+       }
+     }
 
     var providedGen = genFlags.filter { parsedOptions.hasArgument($0) }
-    if parsedOptions.hasArgument(.csProfileGenerate),
-      parsedOptions.hasArgument(.csProfileGenerateEq)
-    {
-      // If both forms were specified, report a clear conflict.
-      diagnosticEngine.emit(
-        .error(Error.conflictingOptions(.csProfileGenerate, .csProfileGenerateEq)),
-        location: nil
-      )
-      providedGen.removeAll { $0 == .csProfileGenerateEq }
-    }
+    resolveDualFormConflict(.irProfileGenerate, .irProfileGenerateEQ)
+    resolveDualFormConflict(.csProfileGenerate, .csProfileGenerateEQ)
 
     guard providedGen.count >= 2 else { return }
     for i in 1..<providedGen.count {
@@ -3371,10 +3375,12 @@ extension Driver {
     let conflictingGenFlags: [Option] = [
       .profileGenerate,
       .irProfileGenerate,
+      .irProfileGenerateEQ,
     ]
     let useProfArgs: [Option] = [
       .profileUse,
       .profileSampleUse,
+      .irProfileUse
     ]
     let providedUse = useProfArgs.filter { parsedOptions.hasArgument($0) }
     guard !providedUse.isEmpty else { return }
@@ -3439,6 +3445,10 @@ extension Driver {
     if let profileSampleUseArg = parsedOptions.getLastArgument(.profileSampleUse)?.asSingle {
       checkForMissingProfilingData([profileSampleUseArg])
     }
+
+    if let irProfileUseArgs = parsedOptions.getLastArgument(.irProfileUse)?.asMultiple {
+      checkForMissingProfilingData(irProfileUseArgs)
+    }
   }
 
   static func validateParseableOutputArgs(_ parsedOptions: inout ParsedOptions,

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -244,8 +244,10 @@ extension Driver {
     try commandLine.appendLast(.suppressWarnings, from: &parsedOptions)
     try commandLine.appendLast(.profileGenerate, from: &parsedOptions)
     try commandLine.appendLast(.irProfileGenerate, from: &parsedOptions)
+    try commandLine.appendLast(.irProfileGenerateEQ, from: &parsedOptions)
+    try commandLine.appendLast(.irProfileUse, from: &parsedOptions)
     try commandLine.appendLast(.csProfileGenerate, from: &parsedOptions)
-    try commandLine.appendLast(.csProfileGenerateEq, from: &parsedOptions)
+    try commandLine.appendLast(.csProfileGenerateEQ, from: &parsedOptions)
     try commandLine.appendLast(.profileUse, from: &parsedOptions)
     try commandLine.appendLast(.profileCoverageMapping, from: &parsedOptions)
     try commandLine.appendLast(.debugInfoForProfiling, from: &parsedOptions)

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -384,23 +384,34 @@ extension Toolchain {
       args.append("-fprofile-generate")
     }
 
+    if options.contains(.irProfileGenerateEQ),
+       let path = options.getLastArgument(.irProfileGenerateEQ)?.asSingle {
+      args.append("-fprofile-generate=\(path)")
+    }
+
     if options.contains(.csProfileGenerate) {
       args.append("-fcs-profile-generate")
     }
 
-    if options.contains(.csProfileGenerateEq),
-       let path = options.getLastArgument(.csProfileGenerateEq)?.asSingle {
+    if options.contains(.csProfileGenerateEQ),
+       let path = options.getLastArgument(.csProfileGenerateEQ)?.asSingle {
       args.append("-fcs-profile-generate=\(path)")
     }
 
+    if options.contains(.irProfileUse),
+       let path = options.getLastArgument(.irProfileUse)?.asMultiple.last {
+      args.append("-fprofile-use=\(path)")
+    }
+
     return args
   }
 
   internal func needsInstrumentedProfile(from parsedOptions: inout ParsedOptions) -> Bool {
     parsedOptions.contains(.profileGenerate) ||
     parsedOptions.contains(.irProfileGenerate) ||
+    parsedOptions.contains(.irProfileGenerateEQ) ||
     parsedOptions.contains(.csProfileGenerate) ||
-    parsedOptions.contains(.csProfileGenerateEq)
+    parsedOptions.contains(.csProfileGenerateEQ)
   }
 }
 

Sources/SwiftOptions/Options.swift

@@ -804,9 +804,6 @@ extension Option {
   public static let printZeroStats: Option = Option("-print-zero-stats", .flag, attributes: [.helpHidden, .frontend], helpText: "Prints all stats even if they are zero")
   public static let profileCoverageMapping: Option = Option("-profile-coverage-mapping", .flag, attributes: [.frontend, .noInteractive], helpText: "Generate coverage data for use with profiled execution counts")
   public static let profileGenerate: Option = Option("-profile-generate", .flag, attributes: [.frontend, .noInteractive], helpText: "Generate instrumented code to collect execution counts")
-  public static let irProfileGenerate: Option = Option("-ir-profile-generate", .flag, attributes: [.frontend, .noInteractive], helpText: "Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)")
-  public static let csProfileGenerate: Option = Option("-cs-profile-generate", .flag, attributes: [.frontend, .noInteractive], helpText: "Generate instrumented code to collect context sensitive execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)")
-  public static let csProfileGenerateEq: Option = Option("-cs-profile-generate=", .joined, attributes: [.frontend, .noInteractive, .argumentIsPath], metaVar: "<dir>", helpText: "Generate instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)")
   public static let profileSampleUse: Option = Option("-profile-sample-use=", .joined, attributes: [.frontend, .noInteractive, .argumentIsPath], metaVar: "<profile data>", helpText: "Supply sampling-based profiling data from llvm-profdata to enable profile-guided optimization")
   public static let profileStatsEntities: Option = Option("-profile-stats-entities", .flag, attributes: [.helpHidden, .frontend], helpText: "Profile changes to stats in -stats-output-dir, subdivided by source entity")
   public static let profileStatsEvents: Option = Option("-profile-stats-events", .flag, attributes: [.helpHidden, .frontend], helpText: "Profile changes to stats in -stats-output-dir")
@@ -1818,9 +1815,6 @@ extension Option {
       Option.printZeroStats,
       Option.profileCoverageMapping,
       Option.profileGenerate,
-      Option.irProfileGenerate,
-      Option.csProfileGenerate,
-      Option.csProfileGenerateEq,
       Option.profileSampleUse,
       Option.profileStatsEntities,
       Option.profileStatsEvents,

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -4911,6 +4911,10 @@ final class SwiftDriverTests: XCTestCase {
       $1.expect(.error(Driver.Error.missingProfilingData(try toPath("profile.profdata").name)))
     }
 
+    try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-ir-profile-use=profile.profdata"]) {
+      $1.expect(.error(Driver.Error.missingProfilingData(try toPath("profile.profdata").name)))
+    }
+
     try withTemporaryDirectory { path in
       try localFileSystem.writeFileContents(path.appending(component: "profile.profdata"), bytes: .init())
       try assertNoDriverDiagnostics(args: "swiftc", "-working-directory", path.pathString, "foo.swift", "-profile-use=profile.profdata")
@@ -4934,15 +4938,40 @@ final class SwiftDriverTests: XCTestCase {
       $1.expect(.error(Driver.Error.conflictingOptions(.profileGenerate, .irProfileGenerate)))
     }
 
+    try withTemporaryDirectory { directoryPath in
+      try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-profile-generate", "-ir-profile-generate=\(directoryPath)"]) {
+        $1.expect(.error(Driver.Error.conflictingOptions(.profileGenerate, .irProfileGenerateEQ)))
+      }
+    }
+
     try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-ir-profile-generate", "-cs-profile-generate"]) {
       $1.expect(.error(Driver.Error.conflictingOptions(.irProfileGenerate, .csProfileGenerate)))
     }
 
     try withTemporaryDirectory { directoryPath in
       try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-ir-profile-generate", "-cs-profile-generate=\(directoryPath)"]) {
-        $1.expect(.error(Driver.Error.conflictingOptions(.irProfileGenerate, .csProfileGenerateEq)))
+        $1.expect(.error(Driver.Error.conflictingOptions(.irProfileGenerate, .csProfileGenerateEQ)))
+      }
+    }
+
+    try withTemporaryDirectory { directoryPath in
+      try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-ir-profile-generate=\(directoryPath)", "-cs-profile-generate=\(directoryPath)"]) {
+        $1.expect(.error(Driver.Error.conflictingOptions(.irProfileGenerateEQ, .csProfileGenerateEQ)))
+      }
+    }
+
+    try withTemporaryDirectory { directoryPath in
+      try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-cs-profile-generate", "-cs-profile-generate=\(directoryPath)"]) {
+        $1.expect(.error(Driver.Error.conflictingOptions(.csProfileGenerate, .csProfileGenerateEQ)))
+      }
+    }
+
+    try withTemporaryDirectory { directoryPath in
+      try assertDriverDiagnostics(args: ["swiftc", "foo.swift", "-ir-profile-generate", "-ir-profile-generate=\(directoryPath)"]) {
+        $1.expect(.error(Driver.Error.conflictingOptions(.irProfileGenerate, .irProfileGenerateEQ)))
       }
     }
+
   }
 
   func testProfileSampleUseFrontendFlags() throws {
@@ -5356,6 +5385,195 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testIRProfileEqLinkerArgs() throws {
+    var envVars = ProcessEnv.block
+    envVars["SWIFT_DRIVER_LD_EXEC"] = ld.nativePathString(escaped: false)
+    try withTemporaryDirectory { directoryPath in
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "x86_64-apple-macosx10.9", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "x86_64-apple-ios7.1-simulator", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "arm64-apple-ios7.1", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "x86_64-apple-tvos9.0-simulator", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "arm64-apple-tvos9.0", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "i386-apple-watchos2.0-simulator", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "armv7k-apple-watchos2.0", "test.swift"],
+                                env: envVars)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        XCTAssert(plannedJobs[1].commandLine.contains(.flag("-fprofile-generate=\(directoryPath)")))
+      }
+
+      // FIXME: This will fail when run on macOS, because
+      // swift-autolink-extract is not present
+      #if os(Linux) || os(Android) || os(Windows)
+      for triple in ["aarch64-unknown-linux-android", "x86_64-unknown-linux-gnu"] {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", triple, "test.swift"])
+        let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+        if triple == "aarch64-unknown-linux-android" {
+          XCTAssert(plannedJobs[1].commandLine.containsPathWithBasename("libclang_rt.profile-aarch64-android.a"))
+        } else {
+          XCTAssert(plannedJobs[1].commandLine.containsPathWithBasename("libclang_rt.profile-x86_64.a"))
+        }
+        XCTAssert(plannedJobs[1].commandLine.contains { $0 == .flag("-u__llvm_profile_runtime") })
+      }
+      #endif
+
+      // -ir-profile-generate should add libclang_rt.profile for WebAssembly targets
+      try withTemporaryDirectory { resourceDir in
+        try localFileSystem.writeFileContents(resourceDir.appending(components: "wasi", "static-executable-args.lnk")) {
+          $0.send("garbage")
+        }
+
+        var env = ProcessEnv.block
+        env["SWIFT_DRIVER_SWIFT_AUTOLINK_EXTRACT_EXEC"] = "//bin/swift-autolink-extract"
+
+        for triple in ["wasm32-unknown-wasi", "wasm32-unknown-wasip1-threads"] {
+          var driver = try Driver(args: [
+            "swiftc", "-ir-profile-generate=\(directoryPath)", "-target", triple, "test.swift",
+            "-resource-dir", resourceDir.pathString
+          ], env: env)
+          let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
+
+          XCTAssertEqual(plannedJobs.count, 2)
+          XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+          XCTAssertEqual(plannedJobs[1].kind, .link)
+          XCTAssert(plannedJobs[1].commandLine.containsPathWithBasename("libclang_rt.profile-wasm32.a"))
+        }
+      }
+
+      for explicitUseLd in [true, false] {
+        var args = ["swiftc", "-ir-profile-generate=\(directoryPath)", "-target", "x86_64-unknown-windows-msvc", "test.swift"]
+        if explicitUseLd {
+          // Explicitly passing '-use-ld=lld' should still result in '-lld-allow-duplicate-weak'.
+          args.append("-use-ld=lld")
+        }
+        var driver = try Driver(args: args)
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+
+        let linkCmds = plannedJobs[1].commandLine
+
+        // rdar://131295678 - Make sure we force the use of lld and pass
+        // '-lld-allow-duplicate-weak'.
+        XCTAssert(linkCmds.contains(.flag("-fuse-ld=lld")))
+        XCTAssert(linkCmds.contains([.flag("-Xlinker"), .flag("-lld-allow-duplicate-weak")]))
+      }
+
+      // rdar://131295678 - Make sure we force the use of lld and pass
+      // '-lld-allow-duplicate-weak' even if the user requests something else.
+      do {
+        var driver = try Driver(args: ["swiftc", "-ir-profile-generate=\(directoryPath)", "-use-ld=link", "-target", "x86_64-unknown-windows-msvc", "test.swift"])
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+
+        let linkCmds = plannedJobs[1].commandLine
+
+        XCTAssertFalse(linkCmds.contains(.flag("-fuse-ld=link")))
+        XCTAssertTrue(linkCmds.contains(.flag("-fuse-ld=lld")))
+        XCTAssertTrue(linkCmds.contains(.flag("-lld-allow-duplicate-weak")))
+      }
+
+      do {
+        // If we're not building for profiling, don't add '-lld-allow-duplicate-weak'.
+        var driver = try Driver(args: ["swiftc", "-use-ld=lld", "-target", "x86_64-unknown-windows-msvc", "test.swift"])
+        let plannedJobs = try driver.planBuild()
+
+        XCTAssertEqual(plannedJobs.count, 2)
+        XCTAssertEqual(plannedJobs[0].kind, .compile)
+
+        XCTAssertEqual(plannedJobs[1].kind, .link)
+
+        let linkCmds = plannedJobs[1].commandLine
+        XCTAssertTrue(linkCmds.contains(.flag("-fuse-ld=lld")))
+        XCTAssertFalse(linkCmds.contains(.flag("-lld-allow-duplicate-weak")))
+      }
+    }
+  }
+
   func testCSProfileLinkerArgs() throws {
     var envVars = ProcessEnv.block
     envVars["SWIFT_DRIVER_LD_EXEC"] = ld.nativePathString(escaped: false)