[clang][driver][darwin] Add driver support for Mac Catalyst

[arphaman]

Summary

This patch is the last patch in the series of patches for the Mac Catalyst support in clang. It adds driver support for the Mac Catalyst target, as supported by the Apple clang compiler. It depends on https://reviews.llvm.org/D105257

[dexonsmith]

LGTM! (Maybe leave a couple of days in case others have comments.)

[leonardchan]

Hi. I think this patch may have led to the test failure we're seeing on our clang builders (https://luci-milo.appspot.com/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8840986998954824016):

Command Output (stderr):
--
/b/s/w/ir/x/w/llvm-project/clang/test/Driver/darwin-ld.c:146:29: error: LINK_VERSION_MIN_MACABI: expected string not found in input
// LINK_VERSION_MIN_MACABI: "-maccatalyst_version_min" "13.1.0"
                            ^
<stdin>:5:15: note: scanning from here
 "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem"
              ^
<stdin>:5:118: note: possible intended match here
 "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem"
                                                                                                                     ^

Input file: <stdin>
Check file: /b/s/w/ir/x/w/llvm-project/clang/test/Driver/darwin-ld.c

-dump-input=help explains the following input dump.

Input was:
<<<<<<
             1: Fuchsia clang version 13.0.0 (https://llvm.googlesource.com/a/llvm-project ae4e8f7d528f650e0f2730a7f166fb0ef7e31588) 
             2: Target: x86_64-apple-darwin10 
             3: Thread model: posix 
             4: InstalledDir: /b/s/w/ir/x/w/staging/llvm_build/bin 
             5:  "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem" 
check:146'0                   X~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: no match found
check:146'1                                                                                                                          ?                                                                                                                                                                possible intended match
             6: Fuchsia clang version 13.0.0 (https://llvm.googlesource.com/a/llvm-project ae4e8f7d528f650e0f2730a7f166fb0ef7e31588) 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             7: Target: x86_64-apple-macosx10.7 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             8: Thread model: posix 
check:146'0     ~~~~~~~~~~~~~~~~~~~~
             9: InstalledDir: /b/s/w/ir/x/w/staging/llvm_build/bin 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            10:  "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.7.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem" 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             .
             .
             .
>>>>>>

--

********************
Testing:  0.. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90.. 
********************
Failed Tests (1):
  Clang :: Driver/darwin-ld.c

Would you mind taking a look and sending out a fix or revert?

[arphaman]

In D105960#2897245, @leonardchan wrote:

Hi. I think this patch may have led to the test failure we're seeing on our clang builders (https://luci-milo.appspot.com/p/fuchsia/builders/toolchain.ci/clang-linux-x64/b8840986998954824016):

Command Output (stderr):
--
/b/s/w/ir/x/w/llvm-project/clang/test/Driver/darwin-ld.c:146:29: error: LINK_VERSION_MIN_MACABI: expected string not found in input
// LINK_VERSION_MIN_MACABI: "-maccatalyst_version_min" "13.1.0"
                            ^
<stdin>:5:15: note: scanning from here
 "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem"
              ^
<stdin>:5:118: note: possible intended match here
 "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem"
                                                                                                                     ^

Input file: <stdin>
Check file: /b/s/w/ir/x/w/llvm-project/clang/test/Driver/darwin-ld.c

-dump-input=help explains the following input dump.

Input was:
<<<<<<
             1: Fuchsia clang version 13.0.0 (https://llvm.googlesource.com/a/llvm-project ae4e8f7d528f650e0f2730a7f166fb0ef7e31588) 
             2: Target: x86_64-apple-darwin10 
             3: Thread model: posix 
             4: InstalledDir: /b/s/w/ir/x/w/staging/llvm_build/bin 
             5:  "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.6.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem" 
check:146'0                   X~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: no match found
check:146'1                                                                                                                          ?                                                                                                                                                                possible intended match
             6: Fuchsia clang version 13.0.0 (https://llvm.googlesource.com/a/llvm-project ae4e8f7d528f650e0f2730a7f166fb0ef7e31588) 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             7: Target: x86_64-apple-macosx10.7 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             8: Thread model: posix 
check:146'0     ~~~~~~~~~~~~~~~~~~~~
             9: InstalledDir: /b/s/w/ir/x/w/staging/llvm_build/bin 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            10:  "/usr/bin/ld" "-demangle" "-lto_library" "/b/s/w/ir/x/w/staging/llvm_build/lib/libLTO.dylib" "-dynamic" "-arch" "x86_64" "-macosx_version_min" "10.7.0" "-o" "a.out" "-lcrt1.10.6.o" "/b/s/w/ir/x/w/staging/llvm_build/tools/clang/test/Driver/Output/darwin-ld.c.tmp.o" "-lSystem" 
check:146'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             .
             .
             .
>>>>>>

--

********************
Testing:  0.. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90.. 
********************
Failed Tests (1):
  Clang :: Driver/darwin-ld.c

Would you mind taking a look and sending out a fix or revert?

Sure, I'll take a look.

[arphaman]

I think this should be fixed if I add -fuse-ld= to the invocation. Let me commit that fix to see if it's fixed.

[arphaman]

I think this should be fixed in 40d2d0c41298f1d8a178216e2534b29e3128cf37.

[leonardchan]

In D105960#2897310, @arphaman wrote:

I think this should be fixed in 40d2d0c41298f1d8a178216e2534b29e3128cf37.

Thanks. Confirmed the test passes locally.

clang/include/clang/Basic/DarwinSDKInfo.h

public:
 
     /// Returns the os-environment mapping pair that's used to represent the
     /// macOS -> Mac Catalyst version mapping.
     static inline constexpr OSEnvPair macOStoMacCatalystPair() {
       return OSEnvPair(llvm::Triple::MacOSX, llvm::Triple::UnknownEnvironment,
                        llvm::Triple::IOS, llvm::Triple::MacABI);
     }
 
+    /// Returns the os-environment mapping pair that's used to represent the
+    /// Mac Catalyst -> macOS version mapping.
+    static inline constexpr OSEnvPair macCatalystToMacOSPair() {
+      return OSEnvPair(llvm::Triple::IOS, llvm::Triple::MacABI,
+                       llvm::Triple::MacOSX, llvm::Triple::UnknownEnvironment);
+    }
+
   private:
     StorageType Value;
 
     friend class DarwinSDKInfo;
   };
 
   /// Represents a version mapping that maps from a version of one target to a
   /// version of a related target.

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_cc_print_options_failure : Error<
     "unable to open CC_PRINT_OPTIONS file: %0">;
 def err_drv_lto_without_lld : Error<"LTO requires -fuse-ld=lld">;
 def err_drv_preamble_format : Error<
     "incorrect format for -preamble-bytes=N,END">;
 def warn_invalid_ios_deployment_target : Warning<
   "invalid iOS deployment version '%0', iOS 10 is the maximum deployment "
   "target for 32-bit targets">, InGroup<InvalidIOSDeploymentTarget>,
   DefaultError;
+def err_invalid_macos_32bit_deployment_target : Error<
+  "32-bit targets are not supported when building for Mac Catalyst">;
 def err_drv_conflicting_deployment_targets : Error<
   "conflicting deployment targets, both '%0' and '%1' are present in environment">;
 def err_arc_unsupported_on_runtime : Error<
   "-fobjc-arc is not supported on platforms using the legacy runtime">;
 def err_arc_unsupported_on_toolchain : Error< // feel free to generalize this
   "-fobjc-arc is not supported on versions of OS X prior to 10.6">;
 def err_objc_weak_with_gc : Error<
   "-fobjc-weak is not supported in Objective-C garbage collection">;

clang/lib/Basic/DarwinSDKInfo.cpp

if (const auto *VM = Obj->getObject("VersionMap")) {
     if (const auto *Mapping = VM->getObject("macOS_iOSMac")) {
       auto VersionMap = RelatedTargetVersionMapping::parseJSON(
           *Mapping, *MaximumDeploymentVersion);
       if (!VersionMap)
         return None;
       VersionMappings[OSEnvPair::macOStoMacCatalystPair().Value] =
           std::move(VersionMap);
     }
+    if (const auto *Mapping = VM->getObject("iOSMac_macOS")) {
+      auto VersionMap = RelatedTargetVersionMapping::parseJSON(
+          *Mapping, *MaximumDeploymentVersion);
+      if (!VersionMap)
+        return None;
+      VersionMappings[OSEnvPair::macCatalystToMacOSPair().Value] =
+          std::move(VersionMap);
+    }
   }
 
   return DarwinSDKInfo(std::move(*Version),
                        std::move(*MaximumDeploymentVersion),
                        std::move(VersionMappings));
 }
 
 Expected<Optional<DarwinSDKInfo>>

clang/lib/Driver/ToolChains/Darwin.h

enum DarwinPlatformKind {
     IPhoneOS,
     TvOS,
     WatchOS,
     LastDarwinPlatform = WatchOS
   };
   enum DarwinEnvironmentKind {
     NativeEnvironment,
     Simulator,
+    MacCatalyst,
   };
 
   mutable DarwinPlatformKind TargetPlatform;
   mutable DarwinEnvironmentKind TargetEnvironment;
 
-  /// The OS version we are targeting.
+  /// The native OS version we are targeting.
   mutable VersionTuple TargetVersion;
+  /// The OS version we are targeting as specified in the triple.
+  mutable VersionTuple OSTargetVersion;
 
   /// The information about the darwin SDK that was used.
   mutable Optional<DarwinSDKInfo> SDKInfo;
 
   CudaInstallationDetector CudaInstallation;
   RocmInstallationDetector RocmInstallation;
 
 private:

 protected:
   /// }
   /// @name Darwin specific Toolchain functions
   /// {
 
   // FIXME: Eliminate these ...Target functions and derive separate tool chains
   // for these targets and put version in constructor.
   void setTarget(DarwinPlatformKind Platform, DarwinEnvironmentKind Environment,
-                 unsigned Major, unsigned Minor, unsigned Micro) const {
+                 unsigned Major, unsigned Minor, unsigned Micro,
+                 VersionTuple NativeTargetVersion) const {
     // FIXME: For now, allow reinitialization as long as values don't
     // change. This will go away when we move away from argument translation.
     if (TargetInitialized && TargetPlatform == Platform &&
         TargetEnvironment == Environment &&
-        TargetVersion == VersionTuple(Major, Minor, Micro))
+        (Environment == MacCatalyst ? OSTargetVersion : TargetVersion) ==
+            VersionTuple(Major, Minor, Micro))
       return;
 
     assert(!TargetInitialized && "Target already initialized!");
     TargetInitialized = true;
     TargetPlatform = Platform;
     TargetEnvironment = Environment;
     TargetVersion = VersionTuple(Major, Minor, Micro);
     if (Environment == Simulator)
       const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::Simulator);
+    else if (Environment == MacCatalyst) {
+      const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::MacABI);
+      TargetVersion = NativeTargetVersion;
+      OSTargetVersion = VersionTuple(Major, Minor, Micro);
+    }
   }
 
 public:
   bool isTargetIPhoneOS() const {
     assert(TargetInitialized && "Target not initialized!");
     return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
            TargetEnvironment == NativeEnvironment;
   }
bool isTargetWatchOSSimulator() const {
     return TargetPlatform == WatchOS && TargetEnvironment == Simulator;
   }
 
   bool isTargetWatchOSBased() const {
     assert(TargetInitialized && "Target not initialized!");
     return TargetPlatform == WatchOS;
   }
 
+  bool isTargetMacCatalyst() const {
+    return TargetPlatform == IPhoneOS && TargetEnvironment == MacCatalyst;
+  }
+
   bool isTargetMacOS() const {
     assert(TargetInitialized && "Target not initialized!");
     return TargetPlatform == MacOS;
   }
 
   bool isTargetMacOSBased() const {
     assert(TargetInitialized && "Target not initialized!");
-    // FIXME (Alex L): Add remaining MacCatalyst suppport.
-    return TargetPlatform == MacOS;
+    return TargetPlatform == MacOS || isTargetMacCatalyst();
   }
 
   bool isTargetAppleSiliconMac() const {
     assert(TargetInitialized && "Target not initialized!");
     return isTargetMacOSBased() && getArch() == llvm::Triple::aarch64;
   }
 
   bool isTargetInitialized() const { return TargetInitialized; }
 
-  VersionTuple getTargetVersion() const {
+  /// The version of the OS that's used by the OS specified in the target
+  /// triple. It might be different from the actual target OS on which the
+  /// program will run, e.g. MacCatalyst code runs on a macOS target, but its
+  /// target triple is iOS.
+  VersionTuple getTripleTargetVersion() const {
     assert(TargetInitialized && "Target not initialized!");
-    return TargetVersion;
+    return isTargetMacCatalyst() ? OSTargetVersion : TargetVersion;
   }
 
   bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
                            unsigned V2 = 0) const {
     assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
     return TargetVersion < VersionTuple(V0, V1, V2);
   }
 
   /// Returns true if the minimum supported macOS version for the slice that's
   /// being built is less than the specified version. If there's no minimum
   /// supported macOS version, the deployment target version is compared to the
   /// specifed version instead.
   bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
-    assert(isTargetMacOS() && getTriple().isMacOSX() &&
+    assert(isTargetMacOSBased() &&
+           (getTriple().isMacOSX() || getTriple().isMacCatalystEnvironment()) &&
            "Unexpected call for non OS X target!");
     // The effective triple might not be initialized yet, so construct a
     // pseudo-effective triple to get the minimum supported OS version.
     VersionTuple MinVers =
         llvm::Triple(getTriple().getArchName(), "apple", "macos")
             .getMinimumSupportedOSVersion();
     return (!MinVers.empty() && MinVers > TargetVersion
                 ? MinVers
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                           llvm::opt::ArgStringList &CC1Args) const override;
   void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                          llvm::opt::ArgStringList &CC1Args) const override;
 
   bool UseObjCMixedDispatch() const override {
     // This is only used with the non-fragile ABI and non-legacy dispatch.
 
     // Mixed dispatch is used everywhere except OS X before 10.6.
-    return !(isTargetMacOS() && isMacosxVersionLT(10, 6));
+    return !(isTargetMacOSBased() && isMacosxVersionLT(10, 6));
   }
 
   LangOptions::StackProtectorMode
   GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
     // Stack protectors default to on for user code on 10.5,
     // and for everything in 10.6 and beyond
     if (isTargetIOSBased() || isTargetWatchOSBased())
       return LangOptions::SSPOn;
-    else if (isTargetMacOS() && !isMacosxVersionLT(10, 6))
+    else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 6))
       return LangOptions::SSPOn;
-    else if (isTargetMacOS() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
+    else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
       return LangOptions::SSPOn;
 
     return LangOptions::SSPOff;
   }
 
   void CheckObjCARC() const override;
 
   llvm::ExceptionHandling GetExceptionModel(

clang/lib/Driver/ToolChains/Darwin.cpp

 #include <cstdlib> // ::getenv
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
+static const VersionTuple minimumMacCatalystDeploymentTarget() {
+  return VersionTuple(13, 1);
+}
+
 llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
   // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
   // archs which Darwin doesn't use.
 
   // The matching this routine does is fairly pointless, since it is neither the
   // complete architecture list, nor a reasonable subset. The problem is that
   // historically the driver driver accepts this and also ties its -march=
   // handling to the architecture name, so we need to be careful before removing
types::ID MachO::LookupTypeForExtension(StringRef Ext) const {
 
   return Ty;
 }
 
 bool MachO::HasNativeLLVMSupport() const { return true; }
 
 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
   // Default to use libc++ on OS X 10.9+ and iOS 7+.
-  if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
-       (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
-       isTargetWatchOSBased())
+  if ((isTargetMacOSBased() && !isMacosxVersionLT(10, 9)) ||
     return ToolChain::CST_Libcxx;
 
   return ToolChain::CST_Libstdcxx;
 }
 
 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
   if (isTargetWatchOSBased())
     return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
   if (isTargetIOSBased())
     return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
   if (isNonFragile)
     return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
   return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
 }
 
 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
 bool Darwin::hasBlocksRuntime() const {
   if (isTargetWatchOSBased())
     return true;
   else if (isTargetIOSBased())
     return !isIPhoneOSVersionLT(3, 2);
   else {
-    assert(isTargetMacOS() && "unexpected darwin target");
+    assert(isTargetMacOSBased() && "unexpected darwin target");
     return !isMacosxVersionLT(10, 6);
   }
 }
 
 void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
                                 ArgStringList &CC1Args) const {
   CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
 }
std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
   if (!isTargetInitialized())
     return Triple.getTriple();
 
   SmallString<16> Str;
   if (isTargetWatchOSBased())
     Str += "watchos";
   else if (isTargetTvOSBased())
     Str += "tvos";
-  else if (isTargetIOSBased())
+  else if (isTargetIOSBased() || isTargetMacCatalyst())
     Str += "ios";
   else
     Str += "macosx";
-  Str += getTargetVersion().getAsString();
+  Str += getTripleTargetVersion().getAsString();
   Triple.setOSName(Str);
 
   return Triple.getTriple();
 }
 
 Tool *MachO::getTool(Action::ActionClass AC) const {
   switch (AC) {
   case Action::LipoJobClass:
static StringRef getXcodeDeveloperPath(StringRef PathIntoXcode) {
   if (Index == StringRef::npos)
     return "";
   return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
 }
 
 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   // Avoid linking compatibility stubs on i386 mac.
-  if (isTargetMacOS() && getArch() == llvm::Triple::x86)
+  if (isTargetMacOSBased() && getArch() == llvm::Triple::x86)
     return;
   if (isTargetAppleSiliconMac())
     return;
   // ARC runtime is supported everywhere on arm64e.
   if (getTriple().isArm64e())
     return;
 
   ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
else
     P += "macosx";
   P += ".a";
 
   CmdArgs.push_back(Args.MakeArgString(P));
 }
 
 unsigned DarwinClang::GetDefaultDwarfVersion() const {
   // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
-  if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
+  if ((isTargetMacOSBased() && isMacosxVersionLT(10, 11)) ||
       (isTargetIOSBased() && isIPhoneOSVersionLT(9)))
     return 2;
   return 4;
 }
 
 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
                               StringRef Component, RuntimeLinkOptions Opts,
                               bool IsShared) const {
void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
   }
 }
 
 StringRef Darwin::getPlatformFamily() const {
   switch (TargetPlatform) {
     case DarwinPlatformKind::MacOS:
       return "MacOSX";
     case DarwinPlatformKind::IPhoneOS:
+      if (TargetEnvironment == MacCatalyst)
+        return "MacOSX";
       return "iPhone";
     case DarwinPlatformKind::TvOS:
       return "AppleTV";
     case DarwinPlatformKind::WatchOS:
       return "Watch";
   }
   llvm_unreachable("Unsupported platform");
 }
StringRef Darwin::getSDKName(StringRef isysroot) {
   return "";
 }
 
 StringRef Darwin::getOSLibraryNameSuffix(bool IgnoreSim) const {
   switch (TargetPlatform) {
   case DarwinPlatformKind::MacOS:
     return "osx";
   case DarwinPlatformKind::IPhoneOS:
+    if (TargetEnvironment == MacCatalyst)
+      return "osx";
     return TargetEnvironment == NativeEnvironment || IgnoreSim ? "ios"
                                                                : "iossim";
   case DarwinPlatformKind::TvOS:
     return TargetEnvironment == NativeEnvironment || IgnoreSim ? "tvos"
                                                                : "tvossim";
   case DarwinPlatformKind::WatchOS:
     return TargetEnvironment == NativeEnvironment || IgnoreSim ? "watchos"
                                                                : "watchossim";
struct DarwinPlatform {
 
   void setOSVersion(StringRef S) {
     assert(Kind == TargetArg && "Unexpected kind!");
     OSVersion = std::string(S);
   }
 
   bool hasOSVersion() const { return HasOSVersion; }
 
+  VersionTuple getNativeTargetVersion() const {
+    assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
+           "native target version is specified only for Mac Catalyst");
+    return NativeTargetVersion;
+  }
+
   /// Returns true if the target OS was explicitly specified.
   bool isExplicitlySpecified() const { return Kind <= DeploymentTargetEnv; }
 
   /// Returns true if the simulator environment can be inferred from the arch.
   bool canInferSimulatorFromArch() const { return InferSimulatorFromArch; }
 
   /// Adds the -m<os>-version-min argument to the compiler invocation.
   void addOSVersionMinArgument(DerivedArgList &Args, const OptTable &Opts) {
case InferredFromArch:
       assert(Argument && "OS version argument not yet inferred");
       return Argument->getAsString(Args);
     case DeploymentTargetEnv:
       return (llvm::Twine(EnvVarName) + "=" + OSVersion).str();
     }
     llvm_unreachable("Unsupported Darwin Source Kind");
   }
 
-  static DarwinPlatform createFromTarget(const llvm::Triple &TT,
-                                         StringRef OSVersion, Arg *A) {
+  static DarwinPlatform
+  createFromTarget(const llvm::Triple &TT, StringRef OSVersion, Arg *A,
+                   const Optional<DarwinSDKInfo> &SDKInfo) {
     DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
                           A);
+    unsigned Major, Minor, Micro;
+    TT.getOSVersion(Major, Minor, Micro);
+    if (Major == 0)
+      Result.HasOSVersion = false;
+
     switch (TT.getEnvironment()) {
     case llvm::Triple::Simulator:
       Result.Environment = DarwinEnvironmentKind::Simulator;
       break;
+    case llvm::Triple::MacABI: {
+      // The minimum native macOS target for MacCatalyst is macOS 10.15.
+      auto NativeTargetVersion = VersionTuple(10, 15);
+      if (Result.HasOSVersion && SDKInfo) {
+        if (const auto *MacCatalystToMacOSMapping = SDKInfo->getVersionMapping(
+                DarwinSDKInfo::OSEnvPair::macCatalystToMacOSPair())) {
+          if (auto MacOSVersion = MacCatalystToMacOSMapping->map(
+                  VersionTuple(Major, Minor, Micro), NativeTargetVersion,
+                  None)) {
+            NativeTargetVersion = *MacOSVersion;
+          }
+        }
+      }
+      Result.Environment = DarwinEnvironmentKind::MacCatalyst;
+      Result.NativeTargetVersion = NativeTargetVersion;
+      break;
+    }
     default:
       break;
     }
-    unsigned Major, Minor, Micro;
-    TT.getOSVersion(Major, Minor, Micro);
-    if (Major == 0)
-      Result.HasOSVersion = false;
     return Result;
   }
   static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform,
                                            Arg *A) {
     return DarwinPlatform(OSVersionArg, Platform, A);
   }
   static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
                                                   StringRef EnvVarName,
static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
     default:
       llvm_unreachable("Unable to infer Darwin variant");
     }
   }
 
   SourceKind Kind;
   DarwinPlatformKind Platform;
   DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
+  VersionTuple NativeTargetVersion;
   std::string OSVersion;
   bool HasOSVersion = true, InferSimulatorFromArch = true;
   Arg *Argument;
   StringRef EnvVarName;
 };
 
 /// Returns the deployment target that's specified using the -m<os>-version-min
 /// argument.
#endif
   if (OSTy == llvm::Triple::UnknownOS)
     return None;
   return DarwinPlatform::createFromArch(OSTy,
                                         getOSVersion(OSTy, Triple, TheDriver));
 }
 
 /// Returns the deployment target that's specified using the -target option.
 Optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
-    DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver) {
+    DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver,
+    const Optional<DarwinSDKInfo> &SDKInfo) {
   if (!Args.hasArg(options::OPT_target))
     return None;
   if (Triple.getOS() == llvm::Triple::Darwin ||
       Triple.getOS() == llvm::Triple::UnknownOS)
     return None;
   std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
-  return DarwinPlatform::createFromTarget(Triple, OSVersion,
-                                          Args.getLastArg(options::OPT_target));
+  return DarwinPlatform::createFromTarget(
+      Triple, OSVersion, Args.getLastArg(options::OPT_target), SDKInfo);
 }
 
 Optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
                                          const ArgList &Args,
                                          const Driver &TheDriver) {
   const Arg *A = Args.getLastArg(options::OPT_isysroot);
   if (!A)
     return None;
void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
   }
 
   // Read the SDKSettings.json file for more information, like the SDK version
   // that we can pass down to the compiler.
   SDKInfo = parseSDKSettings(getVFS(), Args, getDriver());
 
   // The OS and the version can be specified using the -target argument.
   Optional<DarwinPlatform> OSTarget =
-      getDeploymentTargetFromTargetArg(Args, getTriple(), getDriver());
+      getDeploymentTargetFromTargetArg(Args, getTriple(), getDriver(), SDKInfo);
   if (OSTarget) {
     Optional<DarwinPlatform> OSVersionArgTarget =
         getDeploymentTargetFromOSVersionArg(Args, getDriver());
     if (OSVersionArgTarget) {
       unsigned TargetMajor, TargetMinor, TargetMicro;
       bool TargetExtra;
       unsigned ArgMajor, ArgMinor, ArgMicro;
       bool ArgExtra;
if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
           << OSTarget->getAsString(Args, Opts);
   } else if (Platform == IPhoneOS) {
     if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
                                    Micro, HadExtra) ||
         HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << OSTarget->getAsString(Args, Opts);
     ;
+    if (OSTarget->getEnvironment() == MacCatalyst &&
+        (Major < 13 || (Major == 13 && Minor < 1))) {
+      getDriver().Diag(diag::err_drv_invalid_version_number)
+          << OSTarget->getAsString(Args, Opts);
+      Major = 13;
+      Minor = 1;
+      Micro = 0;
+    }
     // For 32-bit targets, the deployment target for iOS has to be earlier than
     // iOS 11.
     if (getTriple().isArch32Bit() && Major >= 11) {
       // If the deployment target is explicitly specified, print a diagnostic.
       if (OSTarget->isExplicitlySpecified()) {
+        if (OSTarget->getEnvironment() == MacCatalyst)
+          getDriver().Diag(diag::err_invalid_macos_32bit_deployment_target);
+        else
           getDriver().Diag(diag::warn_invalid_ios_deployment_target)
               << OSTarget->getAsString(Args, Opts);
         // Otherwise, set it to 10.99.99.
       } else {
         Major = 10;
         Minor = 99;
         Micro = 99;
       }
     }
   } else if (Platform == TvOS) {
if (Platform == MacOS) {
     llvm_unreachable("unknown kind of Darwin platform");
 
   DarwinEnvironmentKind Environment = OSTarget->getEnvironment();
   // Recognize iOS targets with an x86 architecture as the iOS simulator.
   if (Environment == NativeEnvironment && Platform != MacOS &&
       OSTarget->canInferSimulatorFromArch() && getTriple().isX86())
     Environment = Simulator;
 
-  setTarget(Platform, Environment, Major, Minor, Micro);
+  VersionTuple NativeTargetVersion;
+  if (Environment == MacCatalyst)
+    NativeTargetVersion = OSTarget->getNativeTargetVersion();
+  setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
 
   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
     StringRef SDK = getSDKName(A->getValue());
     if (SDK.size() > 0) {
       size_t StartVer = SDK.find_first_of("0123456789");
       StringRef SDKName = SDK.slice(0, StartVer);
       if (!SDKName.startswith(getPlatformFamily()) &&
           !dropSDKNamePrefix(SDKName).startswith(getPlatformFamily()))
void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
   CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic" : "_static";
 
   AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, RLO_IsEmbedded);
 }
 
 bool Darwin::isAlignedAllocationUnavailable() const {
   llvm::Triple::OSType OS;
 
+  if (isTargetMacCatalyst())
+    return TargetVersion < alignedAllocMinVersion(llvm::Triple::MacOSX);
   switch (TargetPlatform) {
   case MacOS: // Earlier than 10.13.
     OS = llvm::Triple::MacOSX;
     break;
   case IPhoneOS:
     OS = llvm::Triple::IOS;
     break;
   case TvOS: // Earlier than 11.0.
void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
   if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
                                 options::OPT_fno_aligned_allocation) &&
       isAlignedAllocationUnavailable())
     CC1Args.push_back("-faligned-alloc-unavailable");
 
   if (SDKInfo) {
     /// Pass the SDK version to the compiler when the SDK information is
     /// available.
+    auto EmitTargetSDKVersionArg = [&](const VersionTuple &V) {
       std::string Arg;
       llvm::raw_string_ostream OS(Arg);
-    OS << "-target-sdk-version=" << SDKInfo->getVersion();
+      OS << "-target-sdk-version=" << V;
       CC1Args.push_back(DriverArgs.MakeArgString(OS.str()));
+    };
+
+    if (isTargetMacCatalyst()) {
+      if (const auto *MacOStoMacCatalystMapping = SDKInfo->getVersionMapping(
+              DarwinSDKInfo::OSEnvPair::macOStoMacCatalystPair())) {
+        Optional<VersionTuple> SDKVersion = MacOStoMacCatalystMapping->map(
+            SDKInfo->getVersion(), minimumMacCatalystDeploymentTarget(), None);
+        EmitTargetSDKVersionArg(
+            SDKVersion ? *SDKVersion : minimumMacCatalystDeploymentTarget());
+      }
+    } else {
+      EmitTargetSDKVersionArg(SDKInfo->getVersion());
+    }
   }
 
   // Enable compatibility mode for NSItemProviderCompletionHandler in
   // Foundation/NSItemProvider.h.
   CC1Args.push_back("-fcompatibility-qualified-id-block-type-checking");
 
   // Give static local variables in inline functions hidden visibility when
   // -fvisibility-inlines-hidden is enabled.

 
 bool MachO::SupportsProfiling() const {
   // Profiling instrumentation is only supported on x86.
   return getTriple().isX86();
 }
 
 void Darwin::addMinVersionArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
-  VersionTuple TargetVersion = getTargetVersion();
+  VersionTuple TargetVersion = getTripleTargetVersion();
 
   if (isTargetWatchOS())
     CmdArgs.push_back("-watchos_version_min");
   else if (isTargetWatchOSSimulator())
     CmdArgs.push_back("-watchos_simulator_version_min");
   else if (isTargetTvOS())
     CmdArgs.push_back("-tvos_version_min");
   else if (isTargetTvOSSimulator())
     CmdArgs.push_back("-tvos_simulator_version_min");
   else if (isTargetIOSSimulator())
     CmdArgs.push_back("-ios_simulator_version_min");
   else if (isTargetIOSBased())
     CmdArgs.push_back("-iphoneos_version_min");
+  else if (isTargetMacCatalyst())
+    CmdArgs.push_back("-maccatalyst_version_min");
   else {
     assert(isTargetMacOS() && "unexpected target");
     CmdArgs.push_back("-macosx_version_min");
   }
 
   VersionTuple MinTgtVers = getEffectiveTriple().getMinimumSupportedOSVersion();
   if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
     TargetVersion = MinTgtVers;
   CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
 }
 
 static const char *getPlatformName(Darwin::DarwinPlatformKind Platform,
                                    Darwin::DarwinEnvironmentKind Environment) {
   switch (Platform) {
   case Darwin::MacOS:
     return "macos";
   case Darwin::IPhoneOS:
-    if (Environment == Darwin::NativeEnvironment ||
-        Environment == Darwin::Simulator)
-      return "ios";
-    // FIXME: Add macCatalyst support here ("\"mac catalyst\"").
-    llvm_unreachable("macCatalyst isn't yet supported");
+    if (Environment == Darwin::MacCatalyst)
+      return "mac catalyst";
   case Darwin::TvOS:
     return "tvos";
   case Darwin::WatchOS:
     return "watchos";
   }
   llvm_unreachable("invalid platform");
 }
 
 void Darwin::addPlatformVersionArgs(const llvm::opt::ArgList &Args,
                                     llvm::opt::ArgStringList &CmdArgs) const {
   // -platform_version <platform> <target_version> <sdk_version>
   // Both the target and SDK version support only up to 3 components.
   CmdArgs.push_back("-platform_version");
   std::string PlatformName = getPlatformName(TargetPlatform, TargetEnvironment);
   if (TargetEnvironment == Darwin::Simulator)
     PlatformName += "-simulator";
   CmdArgs.push_back(Args.MakeArgString(PlatformName));
-  VersionTuple TargetVersion = getTargetVersion().withoutBuild();
+  VersionTuple TargetVersion = getTripleTargetVersion().withoutBuild();
   VersionTuple MinTgtVers = getEffectiveTriple().getMinimumSupportedOSVersion();
   if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
     TargetVersion = MinTgtVers;
   CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
+
+  if (isTargetMacCatalyst()) {
+    // Mac Catalyst programs must use the appropriate iOS SDK version
+    // that corresponds to the macOS SDK version used for the compilation.
+    Optional<VersionTuple> iOSSDKVersion;
+    if (SDKInfo) {
+      if (const auto *MacOStoMacCatalystMapping = SDKInfo->getVersionMapping(
+              DarwinSDKInfo::OSEnvPair::macOStoMacCatalystPair())) {
+        iOSSDKVersion = MacOStoMacCatalystMapping->map(
+            SDKInfo->getVersion().withoutBuild(),
+            minimumMacCatalystDeploymentTarget(), None);
+      }
+    }
+    CmdArgs.push_back(Args.MakeArgString(
+        (iOSSDKVersion ? *iOSSDKVersion : minimumMacCatalystDeploymentTarget())
+            .getAsString()));
+    return;
+  }
+
   if (SDKInfo) {
     VersionTuple SDKVersion = SDKInfo->getVersion().withoutBuild();
     CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
   } else {
     // Use an SDK version that's matching the deployment target if the SDK
     // version is missing. This is preferred over an empty SDK version (0.0.0)
     // as the system's runtime might expect the linked binary to contain a
     // valid SDK version in order for the binary to work correctly. It's
if (D.isTargetMacOS() && D.isMacosxVersionLT(10, 9)) {
     // file and the linker knows to use _main as the entry point.  But,
     // when compiling with -pg, we need to link with the gcrt1.o file,
     // so pass the -no_new_main option to tell the linker to use the
     // "start" symbol as the entry point.
     if (!D.isMacosxVersionLT(10, 8))
       CmdArgs.push_back("-no_new_main");
   } else {
     D.getDriver().Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
-        << D.isTargetMacOS();
+        << D.isTargetMacOSBased();
   }
 }
 
 static void addDefaultCRTLinkArgs(const Darwin &D, const ArgList &Args,
                                   ArgStringList &CmdArgs) {
   // Derived from darwin_crt1 spec.
   if (D.isTargetIPhoneOS()) {
     if (D.getArch() == llvm::Triple::aarch64)
if (isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
       isMacosxVersionLT(10, 5)) {
     const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
     CmdArgs.push_back(Str);
   }
 }
 
 void Darwin::CheckObjCARC() const {
   if (isTargetIOSBased() || isTargetWatchOSBased() ||
-      (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
+      (isTargetMacOSBased() && !isMacosxVersionLT(10, 6)))
     return;
   getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
 }
 
 SanitizerMask Darwin::getSupportedSanitizers() const {
   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
   const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   Res |= SanitizerKind::Leak;
   Res |= SanitizerKind::Fuzzer;
   Res |= SanitizerKind::FuzzerNoLink;
   Res |= SanitizerKind::Function;
   Res |= SanitizerKind::ObjCCast;
 
   // Prior to 10.9, macOS shipped a version of the C++ standard library without
   // C++11 support. The same is true of iOS prior to version 5. These OS'es are
   // incompatible with -fsanitize=vptr.
-  if (!(isTargetMacOS() && isMacosxVersionLT(10, 9))
-      && !(isTargetIPhoneOS() && isIPhoneOSVersionLT(5, 0)))
+  if (!(isTargetMacOSBased() && isMacosxVersionLT(10, 9)) &&
+      !(isTargetIPhoneOS() && isIPhoneOSVersionLT(5, 0)))
     Res |= SanitizerKind::Vptr;
 
-  if ((IsX86_64 || IsAArch64) && isTargetMacOS()) {
+  if ((IsX86_64 || IsAArch64) && isTargetMacOSBased()) {
     Res |= SanitizerKind::Thread;
   } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
     if (IsX86_64)
       Res |= SanitizerKind::Thread;
   }
   return Res;
 }
 
 void Darwin::printVerboseInfo(raw_ostream &OS) const {
   CudaInstallation.print(OS);
   RocmInstallation.print(OS);
 }

clang/test/Driver/Inputs/MacOSX10.15.versioned.sdk/SDKSettings.json

+{
+  "Version":"10.15",
+  "MaximumDeploymentTarget": "10.15.99",
+  "VersionMap" : {
+      "macOS_iOSMac" : {
+          "10.15" : "13.1",
+          "10.15.1" : "13.2"
+      },
+      "iOSMac_macOS" : {
+          "13.1" : "10.15",
+          "13.2" : "10.15.1"
+      }
+  }
+}

clang/test/Driver/darwin-ld-platform-version-maccatalyst.c

+// RUN: touch %t.o
+
+// RUN: %clang -target x86_64-apple-ios13.3-macabi -isysroot %S/Inputs/MacOSX10.14.sdk -mlinker-version=520 -### %t.o 2>&1 \
+// RUN:   | FileCheck %s
+// RUN: %clang -target x86_64-apple-ios13.3-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -mlinker-version=520 -### %t.o 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-MAPPED-SDK %s
+
+// CHECK: "-platform_version" "mac catalyst" "13.3.0" "13.1"
+// CHECK-MAPPED-SDK: "-platform_version" "mac catalyst" "13.3.0" "13.1"

clang/test/Driver/darwin-ld.c

 // RUN: %clang -target x86_64-apple-darwin10 -fuse-ld= -mlinker-version=400 -### %t.o 2> %t.log
 // RUN: %clang -target x86_64-apple-macosx10.7 -fuse-ld= -mlinker-version=400 -### %t.o 2>> %t.log
 // RUN: FileCheck -check-prefix=LINK_VERSION_MIN %s < %t.log
 // LINK_VERSION_MIN: {{ld(.exe)?"}}
 // LINK_VERSION_MIN: "-macosx_version_min" "10.6.0"
 // LINK_VERSION_MIN: {{ld(.exe)?"}}
 // LINK_VERSION_MIN: "-macosx_version_min" "10.7.0"
 
+// RUN: %clang -target x86_64-apple-ios13.1-macabi -mlinker-version=400 -### %t.o 2>> %t.log
+// RUN: FileCheck -check-prefix=LINK_VERSION_MIN_MACABI %s < %t.log
+// LINK_VERSION_MIN_MACABI: {{ld(.exe)?"}}
+// LINK_VERSION_MIN_MACABI: "-maccatalyst_version_min" "13.1.0"
+// LINK_VERSION_MIN_MACABI-NOT: macosx_version_min
+// LINK_VERSION_MIN_MACABI-NOT: macos_version_min
+
 // RUN: %clang -target x86_64-apple-darwin12 -### %t.o 2> %t.log
 // RUN: FileCheck -check-prefix=LINK_NO_CRT1 %s < %t.log
 // LINK_NO_CRT1-NOT: crt
 
 // RUN: %clang -target armv7-apple-ios6.0 -miphoneos-version-min=6.0 -### %t.o 2> %t.log
 // RUN: FileCheck -check-prefix=LINK_NO_IOS_CRT1 %s < %t.log
 // LINK_NO_IOS_CRT1-NOT: crt
 

clang/test/Driver/darwin-mac-catalyst-32bit-not-supported.c

+// RUN: %clang --target=i386-apple-ios13.1-macabi -c -### %s 2>&1 \
+// RUN:   | FileCheck %s
+
+// CHECK: error: 32-bit targets are not supported when building for Mac Catalyst

clang/test/Driver/darwin-maccatalyst.c

+// RUN: %clang -target x86_64-apple-ios13.1-macabi -c %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-VERSION1 %s
+// RUN: %clang -target x86_64-apple-ios13.0-macabi -c %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-ERROR %s
+// RUN: %clang -target x86_64-apple-ios12.0-macabi -c %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-ERROR %s
+
+// CHECK-VERSION1: "x86_64-apple-ios13.1.0-macabi"
+// CHECK-ERROR: error: invalid version number in '-target x86_64-apple-ios

clang/test/Driver/darwin-objc-defaults.m

 // RUN: %clang -target x86_64-apple-darwin10 -S -### %s \
 // RUN:   -arch armv7 -miphoneos-version-min=3.0 2> %t
 // RUN: FileCheck --check-prefix CHECK-CHECK-ARMV7_IPHONE3_0 < %t %s
 
 // CHECK-CHECK-ARMV7_IPHONE3_0: "-cc1"
 // CHECK-CHECK-ARMV7_IPHONE3_0: -fobjc-runtime=ios-3.0
 // CHECK-CHECK-ARMV7_IPHONE3_0-NOT: -fobjc-dispatch-method
 // CHECK-CHECK-ARMV7_IPHONE3_0: darwin-objc-defaults
+
+// RUN: %clang -target x86_64-apple-ios13.1-macabi -S -### %s 2> %t
+// RUN: FileCheck --check-prefix CHECK-CHECK-MACCATALYST < %t %s
+
+// CHECK-CHECK-MACCATALYST: "-cc1"
+// CHECK-CHECK-MACCATALYST: -fobjc-runtime=macosx-10.15
+// CHECK-CHECK-MACCATALYST-NOT: -fobjc-dispatch-method
+// CHECK-CHECK-MACCATALYST: darwin-objc-defaults

clang/test/Driver/darwin-objc-runtime-maccatalyst.m

+// RUN: %clang -target x86_64-apple-ios13.2-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -c %s -### 2>&1 \
+// RUN:   | FileCheck %s
+// RUN: %clang -target x86_64-apple-ios13.2.0-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -c %s -### 2>&1 \
+// RUN:   | FileCheck %s
+// RUN: %clang -target x86_64-apple-ios13.2-macabi -isysroot %S/Inputs/MacOSX10.14.sdk -c %s -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=FALLBACK-DEFAULT %s
+// RUN: %clang -target x86_64-apple-ios12.99.99-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -c %s -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=FALLBACK-DEFAULT %s
+// RUN: %clang -target x86_64-apple-ios-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -c %s -### 2>&1 \
+// RUN:   | FileCheck --check-prefix=FALLBACK-DEFAULT %s
+
+// CHECK: -fobjc-runtime=macosx-10.15.1
+// FALLBACK-DEFAULT: -fobjc-runtime=macosx-10.15

clang/test/Driver/darwin-sanitizer-ld.c

 
 // CHECK-ASAN-WATCHOSSIM: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-WATCHOSSIM-NOT: "-lstdc++"
 // CHECK-ASAN-WATCHOSSIM-NOT: "-lc++"
 // CHECK-ASAN-WATCHOSSIM: libclang_rt.asan_watchossim_dynamic.dylib"
 // CHECK-ASAN-WATCHOSSIM: "-rpath" "@executable_path"
 // CHECK-ASAN-WATCHOSSIM: "-rpath" "{{.*}}lib{{.*}}darwin"
 
+// RUN: %clang -no-canonical-prefixes -### -target x86_64-apple-ios13.1-macabi \
+// RUN:   -stdlib=platform -fsanitize=address \
+// RUN:   -resource-dir %S/Inputs/resource_dir \
+// RUN:   %s -o %t.o 2>&1 | FileCheck --check-prefix=CHECK-ASAN-MACCATALYST %s
+
+// CHECK-ASAN-MACCATALYST: "{{.*}}ld{{(.exe)?}}"
+// CHECK-ASAN-MACCATALYST-NOT: "-lstdc++"
+// CHECK-ASAN-MACCATALYST-NOT: "-lc++"
+// CHECK-ASAN-MACCATALYST: libclang_rt.asan_osx_dynamic.dylib"
+// CHECK-ASAN-MACCATALYST: "-rpath" "@executable_path"
+// CHECK-ASAN-MACCATALYST: "-rpath" "{{.*}}lib{{.*}}darwin"
+
 // RUN: %clang -no-canonical-prefixes -### -target armv7-apple-ios  \
 // RUN:   -stdlib=platform -fsanitize=address -miphoneos-version-min=7 \
 // RUN:   %s -o %t.o 2>&1 | FileCheck --check-prefix=CHECK-ASAN-IOS %s
 
 // CHECK-ASAN-IOS: "{{.*}}ld{{(.exe)?}}"
 // CHECK-ASAN-IOS-NOT: "-lstdc++"
 // CHECK-ASAN-IOS-NOT: "-lc++"
 // CHECK-ASAN-IOS: libclang_rt.asan_ios_dynamic.dylib"

clang/test/Driver/darwin-sdk-version-maccatalyst.c

+// RUN: %clang -target x86_64-apple-ios13.1-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -c -### %s 2>&1 \
+// RUN:   | FileCheck %s
+// RUN: %clang -target x86_64-apple-ios13.99-macabi -isysroot %S/Inputs/MacOSX10.15.versioned.sdk -c -### %s 2>&1 \
+// RUN:   | FileCheck %s
+
+// CHECK: "-target-sdk-version=13.1"