[darwin][driver] isMacosxVersionLT should check against the minimum supported OS version

[arphaman]

Summary

This change ensures that the Darwin driver doesn't add unsupported libraries to the link invocation when linking the Apple Silicon macOS slice.

I also refactored the library adding logic in a pre-commit: https://github.com/llvm/llvm-project/commit/2b00cacb2835d11cab6f71466604b7b1bdd46a8d.

rdar://61011136

[steven_wu]

LGTM

clang/lib/Driver/ToolChains/Darwin.h

public:
   }
 
   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() && "Unexpected call for non OS X target!");
-    return TargetVersion < VersionTuple(V0, V1, V2);
+    assert(isTargetMacOS() && getTriple().isMacOSX() &&
+           "Unexpected call for non OS X target!");
+    VersionTuple MinVers = getTriple().getMinimumSupportedOSVersion();
+    return (!MinVers.empty() && MinVers > TargetVersion
+                ? MinVers
+                : TargetVersion) < VersionTuple(V0, V1, V2);
   }
 
 protected:
   /// Return true if c++17 aligned allocation/deallocation functions are not
   /// implemented in the c++ standard library of the deployment target we are
   /// targeting.
   bool isAlignedAllocationUnavailable() const;
 

clang/test/Driver/macos-apple-silicon-slice-link-libs.cpp

+// RUN: %clang -### -target arm64-apple-macos10.7 %s 2>&1 | FileCheck -check-prefix=ARM64-10_7 %s
+// RUN: %clang -### -target x86_64-apple-macos10.7 %s 2>&1 | FileCheck -check-prefix=x86_64-10_7 %s
+
+// RUN: %clang -### -target arm64-apple-macos10.5 %s 2>&1 | FileCheck -check-prefix=ARM64-10_5 %s
+// RUN: %clang -### -target x86_64-apple-macos10.5 %s 2>&1 | FileCheck -check-prefix=x86_64-10_5 %s
+
+// RUN: %clang -### -target arm64-apple-macos10.4 %s 2>&1 | FileCheck -check-prefix=ARM64-10_4 %s
+// RUN: %clang -### -target x86_64-apple-macos10.4 %s 2>&1 | FileCheck -check-prefix=x86_64-10_4 %s
+
+// RUN: %clang -### -target arm64-apple-macos10.5 -bundle %s 2>&1 | FileCheck -check-prefix=ARM64-BUNDLE %s
+// RUN: %clang -### -target x86_64-apple-macos10.5 -bundle %s 2>&1 | FileCheck -check-prefix=x86_64-BUNDLE %s
+
+// RUN: %clang -### -target arm64-apple-macos10.5 -dynamiclib %s 2>&1 | FileCheck -check-prefix=ARM64-10_5-DYNAMICLIB %s
+// RUN: %clang -### -target x86_64-apple-macos10.5 -dynamiclib %s 2>&1 | FileCheck -check-prefix=x86_64-10_5-DYNAMICLIB %s
+
+// RUN: %clang -### -target arm64-apple-macos10.4 -dynamiclib %s 2>&1 | FileCheck -check-prefix=ARM64-10_4-DYNAMICLIB %s
+// RUN: %clang -### -target x86_64-apple-macos10.4 -dynamiclib %s 2>&1 | FileCheck -check-prefix=x86_64-10_4-DYNAMICLIB %s
+
+// RUN: %clang -### -target arm64-apple-macos10.7 -static %s 2>&1 | FileCheck -check-prefix=STATIC %s
+// RUN: %clang -### -target x86_64-apple-macos10.7 -static %s 2>&1 | FileCheck -check-prefix=STATIC %s
+
+// ARM64-10_7-NOT: -lcrt1.10.6.o
+// x86_64-10_7:    -lcrt1.10.6.o
+
+// ARM64-10_5-NOT: -lcrt1.10.5.o
+// x86_64-10_5:    -lcrt1.10.5.o
+
+// ARM64-10_4-NOT: -lcrt1.o
+// x86_64-10_4:    -lcrt1.o
+
+// ARM64-BUNDLE-NOT: -lbundle1.o
+// x86_64-BUNDLE:    -lbundle1.o
+
+// ARM64-10_5-DYNAMICLIB-NOT: -ldylib1.10.5.o
+// x86_64-10_5-DYNAMICLIB:    -ldylib1.10.5.o
+
+// ARM64-10_4-DYNAMICLIB-NOT: -ldylib1.o
+// x86_64-10_4-DYNAMICLIB:    -ldylib1.o
+
+// STATIC: -lcrt0.o

llvm/include/llvm/ADT/Triple.h

public:
   bool isLittleEndian() const;
 
   /// Test whether target triples are compatible.
   bool isCompatibleWith(const Triple &Other) const;
 
   /// Merge target triples.
   std::string merge(const Triple &Other) const;
 
+  /// Some platforms have different minimum supported OS versions that
+  /// varies by the architecture specified in the triple. This function
+  /// returns the minimum supported OS version for this triple if one an exists,
+  /// or an invalid version tuple if this triple doesn't have one.
+  VersionTuple getMinimumSupportedOSVersion() const;
+
   /// @}
   /// @name Static helpers for IDs.
   /// @{
 
   /// getArchTypeName - Get the canonical name for the \p Kind architecture.
   static StringRef getArchTypeName(ArchType Kind);
 
   /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind

llvm/lib/Support/Triple.cpp

bool Triple::isMacOSXVersionLT(unsigned Major, unsigned Minor,
   if (Major == 10) {
     return isOSVersionLT(Minor + 4, Micro, 0);
   } else {
     assert(Major >= 11 && "Unexpected major version");
     return isOSVersionLT(Major - 11 + 20, Minor, Micro);
   }
 }
 
+VersionTuple Triple::getMinimumSupportedOSVersion() const {
+  if (getVendor() != Triple::Apple || getArch() != Triple::aarch64)
+    return VersionTuple();
+  /// ARM64 slice is supported starting from macOS 11.0+.
+  if (getOS() == Triple::MacOSX)
+    return VersionTuple(11, 0, 0);
+  if (getOS() == Triple::IOS && isMacCatalystEnvironment())
+    return VersionTuple(14, 0, 0);
+  return VersionTuple();
+}
+
 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
   if (MArch.empty())
     MArch = getArchName();
   MArch = ARM::getCanonicalArchName(MArch);
 
   // Some defaults are forced.
   switch (getOS()) {
   case llvm::Triple::FreeBSD: