[Driver/Frontend] Add Driver support for macCatalyst and library search paths

Add support in the driver and frontend for macCatalyst target
targets and library search paths.

The compiler now adds two library search paths for overlays when compiling
for macCatalyst: one for macCatalyst libraries and one for zippered macOS
libraries. The macCatalyst path must take priority over the normal macOS path
so that in the case of 'unzippered twins' the macCatalyst library is
found instead of the macOS library.

To support 'zippered' builds, also add support for a new -target-variant
flag. For zippered libraries, the driver invocation takes both a -target and a
-target-variant flag passes them along to the frontend. We support builds both
when the target is a macOS triple and the target variant is macCatalyst and
also the 'reverse zippered' configuration where the target is macCatalyst and the
target-variant is macOS.

Author: devincoughlin

include/swift/AST/DiagnosticsDriver.def

@@ -117,6 +117,10 @@ ERROR(error_sdk_too_old,none,
 ERROR(error_ios_maximum_deployment_32,none,
       "iOS %0 does not support 32-bit programs", (unsigned))
 
+ERROR(error_unsupported_target_variant,none,
+      "unsupported '%select{-target|-target-variant}1' value '%0'; use 'ios-macabi' instead",
+      (StringRef, bool))
+
 WARNING(warn_arclite_not_found_when_link_objc_runtime,none,
         "unable to find Objective-C runtime support library 'arclite'; "
         "pass '-no-link-objc-runtime' to silence this warning", ())

include/swift/Basic/LangOptions.h

@@ -64,6 +64,17 @@ namespace swift {
     /// This represents the minimum deployment target.
     llvm::Triple Target;
 
+    /// \brief The second target for a zippered build
+    ///
+    /// This represents the target and minimum deployment version for the
+    /// second ('variant') target when performing a zippered build.
+    /// For example, if the target is x86_64-apple-macosx10.14 then
+    /// a target-variant of x86_64-apple-ios12.0-macabi will produce
+    /// a zippered binary that can be loaded into both macCatalyst and
+    /// macOS processes. A value of 'None' means no zippering will be
+    /// performed.
+    llvm::Optional<llvm::Triple> TargetVariant;
+
     ///
     /// Language features
     ///

include/swift/Basic/Platform.h

@@ -46,6 +46,14 @@ namespace swift {
   /// Return true if the given triple represents any simulator.
   bool tripleIsAnySimulator(const llvm::Triple &triple);
 
+  /// Returns true if the given triple represents a macCatalyst environment.
+  bool tripleIsMacCatalystEnvironment(const llvm::Triple &triple);
+
+  /// Returns true if the given -target triple and -target-variant triple
+  /// can be zippered.
+  bool triplesAreValidForZippering(const llvm::Triple &target,
+                                   const llvm::Triple &targetVariant);
+
   /// Returns true if the given triple represents an OS that ships with
   /// ABI-stable swift libraries (eg. in /usr/lib/swift).
   bool tripleRequiresRPathForSwiftInOS(const llvm::Triple &triple);

include/swift/Driver/ToolChain.h

@@ -201,6 +201,11 @@ class ToolChain {
   void getResourceDirPath(SmallVectorImpl<char> &runtimeLibPath,
                           const llvm::opt::ArgList &args, bool shared) const;
 
+  /// Get the secondary runtime library link path given the primary path.
+  void getSecondaryResourceDirPath(
+      SmallVectorImpl<char> &secondaryResourceDirPath,
+      StringRef primaryPath) const;
+
   /// Get the runtime library link paths, which typically include the resource
   /// dir path and the SDK.
   void getRuntimeLibraryPaths(SmallVectorImpl<std::string> &runtimeLibPaths,
@@ -310,7 +315,8 @@ class ToolChain {
   /// An override point for platform-specific subclasses to customize the
   /// validations that should be performed.
   virtual void validateArguments(DiagnosticEngine &diags,
-                                 const llvm::opt::ArgList &args) const {}
+                                 const llvm::opt::ArgList &args,
+                                 StringRef defaultTarget) const {}
 };
 } // end namespace driver
 } // end namespace swift

include/swift/Option/Options.td

@@ -919,6 +919,11 @@ def print_target_info : Flag<["-"], "print-target-info">,
 def target_cpu : Separate<["-"], "target-cpu">, Flags<[FrontendOption, ModuleInterfaceOption]>,
   HelpText<"Generate code for a particular CPU variant">;
 
+def target_variant : Separate<["-"], "target-variant">,
+  Flags<[FrontendOption]>,
+  HelpText<"Generate 'zippered' code for macCatalyst that can run on the specified"
+           " variant target triple in addition to the main -target triple">;
+
 def profile_generate : Flag<["-"], "profile-generate">,
   Flags<[FrontendOption, NoInteractiveOption]>,
   HelpText<"Generate instrumented code to collect execution counts">;

lib/Basic/Platform.cpp

@@ -21,6 +21,7 @@ using namespace swift;
 bool swift::tripleIsiOSSimulator(const llvm::Triple &triple) {
   llvm::Triple::ArchType arch = triple.getArch();
   return (triple.isiOS() &&
+          !tripleIsMacCatalystEnvironment(triple) &&
           // FIXME: transitional, this should eventually stop testing arch, and
           // switch to only checking the -environment field.
           (triple.isSimulatorEnvironment() ||
@@ -54,6 +55,38 @@ bool swift::tripleIsAnySimulator(const llvm::Triple &triple) {
     tripleIsAppleTVSimulator(triple);
 }
 
+bool swift::tripleIsMacCatalystEnvironment(const llvm::Triple &triple) {
+  return triple.isiOS() && !triple.isTvOS() &&
+      triple.getEnvironment() == llvm::Triple::MacABI;
+}
+
+bool swift::triplesAreValidForZippering(const llvm::Triple &target,
+                                        const llvm::Triple &targetVariant) {
+  // The arch and vendor must match.
+  if (target.getArchName() != targetVariant.getArchName() ||
+      target.getArch() != targetVariant.getArch() ||
+      target.getSubArch() != targetVariant.getSubArch() ||
+      target.getVendor() != targetVariant.getVendor()) {
+    return false;
+  }
+
+  // Allow a macOS target and an iOS-macabi target variant
+  // This is typically the case when zippering a library originally
+  // developed for macOS.
+  if (target.isMacOSX() && tripleIsMacCatalystEnvironment(targetVariant)) {
+    return true;
+  }
+
+  // Allow an iOS-macabi target and a macOS target variant. This would
+  // be the case when zippering a library originally developed for
+  // iOS.
+  if (targetVariant.isMacOSX() && tripleIsMacCatalystEnvironment(target)) {
+    return true;
+  }
+
+  return false;
+}
+
 bool swift::tripleRequiresRPathForSwiftInOS(const llvm::Triple &triple) {
   if (triple.isMacOSX()) {
     // macOS 10.14.4 contains a copy of Swift, but the linker will still use an
@@ -304,6 +337,7 @@ getEnvironmentForAppleTargetSpecificModuleTriple(const llvm::Triple &triple) {
               .Cases("unknown", "", None)
   // These values are also supported, but are handled by the default case below:
   //          .Case ("simulator", StringRef("simulator"))
+  //          .Case ("macabi", StringRef("macabi"))
               .Default(tripleEnvironment);
 }
 

lib/Driver/DarwinToolChains.cpp

@@ -96,6 +96,11 @@ getDarwinLibraryNameSuffixForTriple(const llvm::Triple &triple,
   case DarwinPlatformKind::MacOS:
     return "osx";
   case DarwinPlatformKind::IPhoneOS:
+    // Here we return "osx" under the assumption that all the
+    // darwin runtime libraries are zippered and so the "osx" variants
+    // should be used for macCatalyst targets.
+    if (tripleIsMacCatalystEnvironment(triple))
+        return "osx";
     return "ios";
   case DarwinPlatformKind::IPhoneOSSimulator:
     return "iossim";
@@ -431,6 +436,9 @@ toolchains::Darwin::addArgsToLinkStdlib(ArgStringList &Arguments,
     // package isn't installed.
     Arguments.push_back("-rpath");
     Arguments.push_back(context.Args.MakeArgString("/usr/lib/swift"));
+    // We don't need an rpath for /System/iOSSupport/usr/lib/swift because...
+    assert(!tripleIsMacCatalystEnvironment(getTriple())
+           && "macCatalyst not supported without Swift-in-the-OS");
   }
 }
 
@@ -489,12 +497,23 @@ toolchains::Darwin::addDeploymentTargetArgs(ArgStringList &Arguments,
     } else {
       if (isiOSSimulator)
         Arguments.push_back("-ios_simulator_version_min");
+      else if (tripleIsMacCatalystEnvironment(Triple))
+        Arguments.push_back("-maccatalyst_version_min");
       else
         Arguments.push_back("-iphoneos_version_min");
     }
     unsigned major, minor, micro;
     Triple.getiOSVersion(major, minor, micro);
     addVersionString(context.Args, Arguments, major, minor, micro);
+
+    if (TargetVariant) {
+      assert(triplesAreValidForZippering(Triple, *TargetVariant));
+      assert(TargetVariant->isMacOSX());
+      Arguments.push_back("-macosx_version_min");
+      unsigned major, minor, micro;
+      TargetVariant->getMacOSXVersion(major, minor, micro);
+      addVersionString(context.Args, Arguments, major, minor, micro);
+    }
   } else if (Triple.isWatchOS()) {
     if (tripleIsWatchSimulator(Triple))
       Arguments.push_back("-watchos_simulator_version_min");
@@ -508,6 +527,15 @@ toolchains::Darwin::addDeploymentTargetArgs(ArgStringList &Arguments,
     unsigned major, minor, micro;
     Triple.getMacOSXVersion(major, minor, micro);
     addVersionString(context.Args, Arguments, major, minor, micro);
+
+    if (TargetVariant) {
+      assert(triplesAreValidForZippering(Triple, *TargetVariant));
+      assert(tripleIsMacCatalystEnvironment(*TargetVariant));
+      Arguments.push_back("-maccatalyst_version_min");
+      unsigned major, minor, micro;
+      TargetVariant->getiOSVersion(major, minor, micro);
+      addVersionString(context.Args, Arguments, major, minor, micro);
+    }
   }
 }
 
@@ -718,15 +746,33 @@ static void validateDeploymentTarget(const toolchains::Darwin &TC,
   }
 }
 
+static void validateTargetVariant(const toolchains::Darwin &TC,
+                                  DiagnosticEngine &diags,
+                                  const llvm::opt::ArgList &args,
+                                  StringRef defaultTarget) {
+  if (TC.getTargetVariant().hasValue()) {
+    auto target = TC.getTriple();
+    auto variant = *TC.getTargetVariant();
+
+    if (!triplesAreValidForZippering(target, variant)) {
+      diags.diagnose(SourceLoc(), diag::error_unsupported_target_variant,
+                    variant.str(),
+                    variant.isiOS());
+    }
+  }
+}
+
 void 
 toolchains::Darwin::validateArguments(DiagnosticEngine &diags,
-                                      const llvm::opt::ArgList &args) const {
+                                      const llvm::opt::ArgList &args,
+                                      StringRef defaultTarget) const {
   // Validating arclite library path when link-objc-runtime.
   validateLinkObjcRuntimeARCLiteLib(*this, diags, args);
 
   // Validating apple platforms deployment targets.
   validateDeploymentTarget(*this, diags, args);
-    
+  validateTargetVariant(*this, diags, args, defaultTarget);
+
   // Validating darwin unsupported -static-stdlib argument.
   if (args.hasArg(options::OPT_static_stdlib)) {
     diags.diagnose(SourceLoc(), diag::error_darwin_static_stdlib_not_supported);

lib/Driver/Driver.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/DiagnosticsFrontend.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OutputFileMap.h"
+#include "swift/Basic/Platform.h"
 #include "swift/Basic/Range.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/TaskQueue.h"
@@ -252,8 +253,13 @@ Driver::buildToolChain(const llvm::opt::InputArgList &ArgList) {
   case llvm::Triple::MacOSX:
   case llvm::Triple::IOS:
   case llvm::Triple::TvOS:
-  case llvm::Triple::WatchOS:
-    return llvm::make_unique<toolchains::Darwin>(*this, target);
+  case llvm::Triple::WatchOS: {
+    Optional<llvm::Triple> targetVariant;
+    if (const Arg *A = ArgList.getLastArg(options::OPT_target_variant))
+      targetVariant = llvm::Triple(llvm::Triple::normalize(A->getValue()));
+
+    return llvm::make_unique<toolchains::Darwin>(*this, target, targetVariant);
+  }
   case llvm::Triple::Linux:
     if (target.isAndroid())
       return llvm::make_unique<toolchains::Android>(*this, target);
@@ -824,7 +830,7 @@ Driver::buildCompilation(const ToolChain &TC,
   validateArgs(Diags, *TranslatedArgList, TC.getTriple());
 
   // Perform toolchain specific args validation.
-  TC.validateArguments(Diags, *TranslatedArgList);
+  TC.validateArguments(Diags, *TranslatedArgList, DefaultTargetTriple);
 
   if (Diags.hadAnyError())
     return nullptr;

lib/Driver/ToolChains.cpp

@@ -151,6 +151,12 @@ static void addCommonFrontendArgs(const ToolChain &TC, const OutputInfo &OI,
     break;
   }
 
+  if (const Arg *variant = inputArgs.getLastArg(options::OPT_target_variant)) {
+    arguments.push_back("-target-variant");
+    std::string normalized = llvm::Triple::normalize(variant->getValue());
+    arguments.push_back(inputArgs.MakeArgString(normalized));
+  }
+
   // Enable address top-byte ignored in the ARM64 backend.
   if (Triple.getArch() == llvm::Triple::aarch64) {
     arguments.push_back("-Xllvm");
@@ -1223,8 +1229,28 @@ void ToolChain::getResourceDirPath(SmallVectorImpl<char> &resourceDirPath,
     llvm::sys::path::append(resourceDirPath, "lib",
                             shared ? "swift" : "swift_static");
   }
-  llvm::sys::path::append(resourceDirPath,
-                          getPlatformNameForTriple(getTriple()));
+
+  StringRef libSubDir = getPlatformNameForTriple(getTriple());
+  if (tripleIsMacCatalystEnvironment(getTriple()))
+    libSubDir = "maccatalyst";
+  llvm::sys::path::append(resourceDirPath, libSubDir);
+}
+
+// Get the secondary runtime library link path given the primary path.
+// The compiler will look for runtime libraries in the secondary path if they
+// can't be found in the primary path.
+void ToolChain::getSecondaryResourceDirPath(
+    SmallVectorImpl<char> &secondaryResourceDirPath,
+    StringRef primaryPath) const {
+  if (!tripleIsMacCatalystEnvironment(getTriple()))
+    return;
+
+  // For macCatalyst, the secondary runtime library path is the macOS library
+  // path. The compiler will find zippered libraries here.
+  secondaryResourceDirPath.append(primaryPath.begin(), primaryPath.end());
+  // Remove '/maccatalyst' and replace with 'macosx'.
+  llvm::sys::path::remove_filename(secondaryResourceDirPath);
+  llvm::sys::path::append(secondaryResourceDirPath, "macosx");
 }
 
 void ToolChain::getRuntimeLibraryPaths(SmallVectorImpl<std::string> &runtimeLibPaths,
@@ -1234,7 +1260,22 @@ void ToolChain::getRuntimeLibraryPaths(SmallVectorImpl<std::string> &runtimeLibP
   getResourceDirPath(scratchPath, args, shared);
   runtimeLibPaths.push_back(scratchPath.str());
 
+  // If there's a secondary resource dir, add it too.
+  scratchPath.clear();
+  getSecondaryResourceDirPath(scratchPath, runtimeLibPaths[0]);
+  if (!scratchPath.empty())
+    runtimeLibPaths.push_back(scratchPath.str());
+
   if (!SDKPath.empty()) {
+    if (!scratchPath.empty()) {
+      // If we added the secondary resource dir, we also need the iOSSupport
+      // directory.
+      scratchPath = SDKPath;
+      llvm::sys::path::append(scratchPath, "System", "iOSSupport");
+      llvm::sys::path::append(scratchPath, "usr", "lib", "swift");
+      runtimeLibPaths.push_back(scratchPath.str());
+    }
+
     scratchPath = SDKPath;
     llvm::sys::path::append(scratchPath, "usr", "lib", "swift");
     runtimeLibPaths.push_back(scratchPath.str());

lib/Driver/ToolChains.h

@@ -55,17 +55,27 @@ class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
                                      const JobContext &context) const override;
 
   void validateArguments(DiagnosticEngine &diags,
-                         const llvm::opt::ArgList &args) const override;
+                         const llvm::opt::ArgList &args,
+                         StringRef defaultTarget) const override;
 
   std::string findProgramRelativeToSwiftImpl(StringRef name) const override;
 
   bool shouldStoreInvocationInDebugInfo() const override;
 
+  const Optional<llvm::Triple> TargetVariant;
+
 public:
-  Darwin(const Driver &D, const llvm::Triple &Triple) : ToolChain(D, Triple) {}
+  Darwin(const Driver &D, const llvm::Triple &Triple,
+         const Optional<llvm::Triple> &TargetVariant) :
+      ToolChain(D, Triple), TargetVariant(TargetVariant) {}
+
   ~Darwin() = default;
   std::string sanitizerRuntimeLibName(StringRef Sanitizer,
                                       bool shared = true) const override;
+  
+  Optional<llvm::Triple> getTargetVariant() const {
+    return TargetVariant;
+  }
 };
 
 class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {