[Clang] Add DriverKit support

[egorzhdan]

Summary

This is the second patch that upstreams the support for Apple's DriverKit.

The first patch: https://reviews.llvm.org/D118046.

[egorzhdan]

Fix clang-format warnings

[arphaman]

LGTM, with one request.

Can you please take the static analyzer changes (RetainSummaryManager.h/cpp) and make them into a separate patch? Please add @NoQ as a reviewer for that change.

Then feel free to land the remaining driver kit changes in this patch as one commit.

[egorzhdan]

Remove static analyzer changes

clang/include/clang/Analysis/RetainSummaryManager.h

class RetainSummaryManager {
   /// ObjCInitRetE - Default return effect for init methods returning
   ///   Objective-C objects.
   RetEffect ObjCInitRetE;
 
   /// SimpleSummaries - Used for uniquing summaries that don't have special
   /// effects.
   llvm::FoldingSet<CachedSummaryNode> SimpleSummaries;
 
+  /// Create arg effects to all OS object out parameters.
+  ArgEffects getOSOutParametersMap(const FunctionDecl *FD, ArgEffectKind AEK);
+
+  /// Create +1 arg effects to all OS object out parameters. Takes return type
+  /// into account if it's a kern_return_t or an OSObject *.
+  ArgEffects getOSOutParamsCreateRuleMap(const FunctionDecl *FD);
+
+  /// Create +0 arg effects to all OS object out parameters.
+  ArgEffects getOSOutParamsGetRuleMap(const FunctionDecl *FD);
+
   /// Create an OS object at +1.
   const RetainSummary *getOSSummaryCreateRule(const FunctionDecl *FD);
 
+  /// Create an OS object at +1 and create out-parameters at +1.
+  const RetainSummary *
+  getOSSummaryCreateRuleWithOutParams(const FunctionDecl *FD);
+
+  /// Create an OS object at +0 and create out-parameters at +0.
+  const RetainSummary *getOSSummaryGetRuleWithOutParams(const FunctionDecl *FD);
+
   /// Get an OS object at +0.
   const RetainSummary *getOSSummaryGetRule(const FunctionDecl *FD);
 
+  /// Create out-parameters at +1, don't care about the return value.
+  const RetainSummary *
+  getOSSummaryCreateRuleOutParamsOnly(const FunctionDecl *FD);
+
+  /// Create out-parameters at +0, don't care about the return value.
+  const RetainSummary *getOSSummaryGetRuleOutParamsOnly(const FunctionDecl *FD);
+
   /// Increment the reference count on OS object.
   const RetainSummary *getOSSummaryRetainRule(const FunctionDecl *FD);
 
   /// Decrement the reference count on OS object.
   const RetainSummary *getOSSummaryReleaseRule(const FunctionDecl *FD);
 
   /// Free the OS object.
   const RetainSummary *getOSSummaryFreeRule(const FunctionDecl *FD);

clang/include/clang/Basic/Attr.td

 [{static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
     return llvm::StringSwitch<llvm::StringRef>(Platform)
              .Case("android", "Android")
              .Case("fuchsia", "Fuchsia")
              .Case("ios", "iOS")
              .Case("macos", "macOS")
              .Case("tvos", "tvOS")
              .Case("watchos", "watchOS")
+             .Case("driverkit", "DriverKit")
              .Case("ios_app_extension", "iOS (App Extension)")
              .Case("macos_app_extension", "macOS (App Extension)")
              .Case("tvos_app_extension", "tvOS (App Extension)")
              .Case("watchos_app_extension", "watchOS (App Extension)")
              .Case("maccatalyst", "macCatalyst")
              .Case("maccatalyst_app_extension", "macCatalyst (App Extension)")
              .Case("swift", "Swift")
              .Default(llvm::StringRef());

clang/include/clang/Basic/AttrDocs.td

 
 ``tvos``
   Apple's tvOS operating system. The minimum deployment target is specified by
   the ``-mtvos-version-min=*version*`` command-line argument.
 
 ``watchos``
   Apple's watchOS operating system. The minimum deployment target is specified by
   the ``-mwatchos-version-min=*version*`` command-line argument.
   
+``driverkit``
+  Apple's DriverKit userspace kernel extensions. The minimum deployment target
+  is specified as part of the triple.
+
 A declaration can typically be used even when deploying back to a platform
 version prior to when the declaration was introduced. When this happens, the
 declaration is `weakly linked
 <https://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPFrameworks/Concepts/WeakLinking.html>`_,
 as if the ``weak_import`` attribute were added to the declaration. A
 weakly-linked declaration may or may not be present a run-time, and a program
 can determine whether the declaration is present by checking whether the
 address of that declaration is non-NULL.

clang/include/clang/Basic/Features.def

 FEATURE(assume_nonnull, true)
 FEATURE(attribute_analyzer_noreturn, true)
 FEATURE(attribute_availability, true)
 FEATURE(attribute_availability_with_message, true)
 FEATURE(attribute_availability_app_extension, true)
 FEATURE(attribute_availability_with_version_underscores, true)
 FEATURE(attribute_availability_tvos, true)
 FEATURE(attribute_availability_watchos, true)
+FEATURE(attribute_availability_driverkit, true)
 FEATURE(attribute_availability_with_strict, true)
 FEATURE(attribute_availability_with_replacement, true)
 FEATURE(attribute_availability_in_templates, true)
 FEATURE(attribute_availability_swift, true)
 FEATURE(attribute_cf_returns_not_retained, true)
 FEATURE(attribute_cf_returns_retained, true)
 FEATURE(attribute_cf_returns_on_parameters, true)
 FEATURE(attribute_deprecated_with_message, true)

clang/include/clang/Driver/Options.td

def nogpuinc : Flag<["-"], "nogpuinc">, HelpText<"Do not add include paths for CUDA/HIP and"
   " do not include the default CUDA/HIP wrapper headers">;
 def nohipwrapperinc : Flag<["-"], "nohipwrapperinc">,
   HelpText<"Do not include the default HIP wrapper headers and include paths">;
 def : Flag<["-"], "nocudainc">, Alias<nogpuinc>;
 def nogpulib : Flag<["-"], "nogpulib">,
   HelpText<"Do not link device library for CUDA/HIP device compilation">;
 def : Flag<["-"], "nocudalib">, Alias<nogpulib>;
 def nodefaultlibs : Flag<["-"], "nodefaultlibs">;
+def nodriverkitlib : Flag<["-"], "nodriverkitlib">;
 def nofixprebinding : Flag<["-"], "nofixprebinding">;
 def nolibc : Flag<["-"], "nolibc">;
 def nomultidefs : Flag<["-"], "nomultidefs">;
 def nopie : Flag<["-"], "nopie">;
 def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
 def noprebind : Flag<["-"], "noprebind">;
 def noprofilelib : Flag<["-"], "noprofilelib">;
 def noseglinkedit : Flag<["-"], "noseglinkedit">;

clang/lib/Analysis/RetainSummaryManager.cpp

 //== RetainSummaryManager.cpp - Summaries for reference counting --*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines summaries implementation for retain counting, which
 //  implements a reference count checker for Core Foundation, Cocoa
 //  and OSObject (on Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
 #include "clang/Analysis/RetainSummaryManager.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/TargetInfo.h"
 
 using namespace clang;
 using namespace ento;
 
 template <class T>
 constexpr static bool isOneOf() {
   return false;
 }
RetainSummaryManager::isKnownSmartPointer(QualType QT) {
   const IdentifierInfo *II = RD->getIdentifier();
   if (II && II->getName() == "smart_ptr")
     if (const auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext()))
       if (ND->getNameAsString() == "os")
         return true;
   return false;
 }
 
+static bool isDriverKitGetter(StringRef FName) {
+  llvm::Regex Re("(.*)Get([A-Z_]|$)(.*)");
+  return FName.startswith("get") || Re.match(FName);
+}
+
 const RetainSummary *
 RetainSummaryManager::getSummaryForOSObject(const FunctionDecl *FD,
                                             StringRef FName, QualType RetTy) {
   assert(TrackOSObjects &&
          "Requesting a summary for an OSObject but OSObjects are not tracked");
 
+  if (Ctx.getTargetInfo().getTriple().isDriverKit()) {
+    const FunctionType *FT = FD->getType()->getAs<FunctionType>();
+    if (FName == "OSObjectRetain")
+      return getUnarySummary(FT, IncRef);
+    if (FName == "OSObjectRelease")
+      return getUnarySummary(FT, DecRef);
+  }
+
   if (RetTy->isPointerType()) {
     const CXXRecordDecl *PD = RetTy->getPointeeType()->getAsCXXRecordDecl();
     if (PD && isOSObjectSubclass(PD)) {
       if (isOSObjectDynamicCast(FName) || isOSObjectRequiredCast(FName) ||
           isOSObjectThisCast(FName))
         return getDefaultSummary();
 
       // TODO: Add support for the slightly common *Matching(table) idiom.
       // Cf. IOService::nameMatching() etc. - these function have an unusual
       // contract of returning at +0 or +1 depending on their last argument.
       if (FName.endswith("Matching")) {
         return getPersistentStopSummary();
       }
 
+      if (Ctx.getTargetInfo().getTriple().isDriverKit()) {
+        if (isDriverKitGetter(FName) || isOSIteratorSubclass(PD))
+          return getOSSummaryGetRuleWithOutParams(FD);
+        else
+          return getOSSummaryCreateRuleWithOutParams(FD);
+      } else {
         // All objects returned with functions *not* starting with 'get',
         // or iterators, are returned at +1.
         if ((!FName.startswith("get") && !FName.startswith("Get")) ||
             isOSIteratorSubclass(PD)) {
           return getOSSummaryCreateRule(FD);
         } else {
           return getOSSummaryGetRule(FD);
         }
       }
     }
+  } else if (Ctx.getTargetInfo().getTriple().isDriverKit()) {
+    // Under DriverKit we assume the create rule (depending on return values)
+    // for out-parameters by default.
+    if (isDriverKitGetter(FName)) {
+      if (const RetainSummary *Summ = getOSSummaryGetRuleOutParamsOnly(FD))
+        return Summ;
+    } else {
+      if (const RetainSummary *Summ = getOSSummaryCreateRuleOutParamsOnly(FD))
+        return Summ;
+    }
+  }
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
     const CXXRecordDecl *Parent = MD->getParent();
     if (Parent && isOSObjectSubclass(Parent)) {
       if (FName == "release" || FName == "taggedRelease")
         return getOSSummaryReleaseRule(FD);
 
       if (FName == "retain" || FName == "taggedRetain")
if (CE->getNumArgs() == 1 &&
       return BehaviorSummary::Identity;
 
     // safeMetaCast is called by OSDynamicCast.
     // We assume that OSDynamicCast is either an identity (cast is OK,
     // the input was non-zero),
     // or that it returns zero (when the cast failed, or the input
     // was zero).
     if (TrackOSObjects) {
+      if (FName == "OSObjectRetain" || FName == "OSObjectRelease")
+        return BehaviorSummary::NoOp;
+
       if (isOSObjectDynamicCast(FName) && FD->param_size() >= 1) {
         return BehaviorSummary::IdentityOrZero;
       } else if (isOSObjectRequiredCast(FName) && FD->param_size() >= 1) {
         return BehaviorSummary::Identity;
       } else if (isOSObjectThisCast(FName) && isa<CXXMethodDecl>(FD) &&
                  !cast<CXXMethodDecl>(FD)->isStatic()) {
         return BehaviorSummary::IdentityThis;
       }
RetainSummaryManager::getUnarySummary(const FunctionType* FT,
   ArgEffect Effect(AE, ObjKind::CF);
 
   ScratchArgs = AF.add(ScratchArgs, 0, Effect);
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               ScratchArgs,
                               ArgEffect(DoNothing), ArgEffect(DoNothing));
 }
 
+/// \return Whether the chain of typedefs starting from @c QT
+/// has a typedef with a given name @c Name.
+static bool hasTypedefNamed(QualType QT, StringRef Name) {
+  while (auto *T = dyn_cast<TypedefType>(QT)) {
+    const auto &Context = T->getDecl()->getASTContext();
+    if (T->getDecl()->getIdentifier() == &Context.Idents.get(Name))
+      return true;
+    QT = T->getDecl()->getUnderlyingType();
+  }
+  return false;
+}
+
+ArgEffects RetainSummaryManager::getOSOutParametersMap(const FunctionDecl *FD,
+                                                       ArgEffectKind AEK) {
+  ArgEffects AE = AF.getEmptyMap();
+  for (unsigned I = 0, E = FD->getNumParams(); I != E; ++I) {
+    QualType T = FD->parameters()[I]->getType();
+    if (!T->isPointerType())
+      continue;
+
+    T = T->getPointeeType();
+    // If it's a const pointer, it's not an out-parameter,
+    // because you cannot write into a const pointer.
+    if (T.isConstQualified() || !isOSObjectPtr(T))
+      continue;
+
+    AE = AF.add(AE, I, ArgEffect(AEK, ObjKind::OS));
+  }
+  return AE;
+}
+
+ArgEffects
+RetainSummaryManager::getOSOutParamsCreateRuleMap(const FunctionDecl *FD) {
+  QualType RT = FD->getReturnType();
+  ArgEffectKind AEK = hasTypedefNamed(RT, "kern_return_t")
+                          ? RetainedOutParameterOnZero
+                      : (isOSObjectPtr(RT) || RT->isBooleanType())
+                          ? RetainedOutParameterOnNonZero
+                          : RetainedOutParameter;
+  return getOSOutParametersMap(FD, AEK);
+}
+
+ArgEffects
+RetainSummaryManager::getOSOutParamsGetRuleMap(const FunctionDecl *FD) {
+  // Here we assume that if the function follows the "Get" rule,
+  // the rule is also applied to out-parameters. It sounds intuitive
+  // and easy to remember that the same rules apply regardless of
+  // how is the value returned.
+  return getOSOutParametersMap(FD, UnretainedOutParameter);
+}
+
 const RetainSummary *
 RetainSummaryManager::getOSSummaryRetainRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               AF.getEmptyMap(),
                               /*ReceiverEff=*/ArgEffect(DoNothing),
                               /*DefaultEff=*/ArgEffect(DoNothing),
                               /*ThisEff=*/ArgEffect(IncRef, ObjKind::OS));
 }

 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryCreateRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeOwned(ObjKind::OS),
                               AF.getEmptyMap());
 }
 
+const RetainSummary *RetainSummaryManager::getOSSummaryCreateRuleWithOutParams(
+    const FunctionDecl *FD) {
+  return getPersistentSummary(RetEffect::MakeOwned(ObjKind::OS),
+                              getOSOutParamsCreateRuleMap(FD));
+}
+
 const RetainSummary *
 RetainSummaryManager::getOSSummaryGetRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::OS),
                               AF.getEmptyMap());
 }
 
 const RetainSummary *
+RetainSummaryManager::getOSSummaryGetRuleWithOutParams(const FunctionDecl *FD) {
+  return getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::OS),
+                              getOSOutParamsGetRuleMap(FD));
+}
+
+const RetainSummary *RetainSummaryManager::getOSSummaryCreateRuleOutParamsOnly(
+    const FunctionDecl *FD) {
+  ArgEffects AE = getOSOutParamsCreateRuleMap(FD);
+  // If this function has no OSObject out-parameters, we shouldn't model it,
+  // because there's nothing remaining to model.
+  if (AE.isEmpty())
+    return nullptr;
+  return getPersistentSummary(RetEffect::MakeNoRet(), AE);
+}
+
+const RetainSummary *
+RetainSummaryManager::getOSSummaryGetRuleOutParamsOnly(const FunctionDecl *FD) {
+  ArgEffects AE = getOSOutParamsGetRuleMap(FD);
+  // If this function has no OSObject out-parameters, we shouldn't model it,
+  // because there's nothing remaining to model.
+  if (AE.isEmpty())
+    return nullptr;
+  return getPersistentSummary(RetEffect::MakeNoRet(), AE);
+}
+
+const RetainSummary *
 RetainSummaryManager::getCFSummaryCreateRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF),
                               ArgEffects(AF.getEmptyMap()));
 }
 
 const RetainSummary *
 RetainSummaryManager::getCFSummaryGetRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::CF),
RetainSummaryManager::getRetEffectFromAnnotations(QualType RetTy,
   if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
     for (const auto *PD : MD->overridden_methods())
       if (auto RE = getRetEffectFromAnnotations(RetTy, PD))
         return RE;
 
   return None;
 }
 
-/// \return Whether the chain of typedefs starting from @c QT
-/// has a typedef with a given name @c Name.
-static bool hasTypedefNamed(QualType QT,
-                            StringRef Name) {
-  while (auto *T = dyn_cast<TypedefType>(QT)) {
-    const auto &Context = T->getDecl()->getASTContext();
-    if (T->getDecl()->getIdentifier() == &Context.Idents.get(Name))
-      return true;
-    QT = T->getDecl()->getUnderlyingType();
-  }
-  return false;
-}
-
 static QualType getCallableReturnType(const NamedDecl *ND) {
   if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
     return FD->getReturnType();
   } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(ND)) {
     return MD->getReturnType();
   } else {
     llvm_unreachable("Unexpected decl");
   }

clang/lib/Basic/Targets/OSTargets.h

else if (Triple.isiOS()) {
         else
           this->TLSSupported = !Triple.isOSVersionLT(10);
       }
     } else if (Triple.isWatchOS()) {
       if (!Triple.isSimulatorEnvironment())
         this->TLSSupported = !Triple.isOSVersionLT(2);
       else
         this->TLSSupported = !Triple.isOSVersionLT(3);
+    } else if (Triple.isDriverKit()) {
+      // No TLS on DriverKit.
     }
 
     this->MCountName = "\01mcount";
   }
 
   const char *getStaticInitSectionSpecifier() const override {
     // FIXME: We should return 0 when building kexts.
     return "__TEXT,__StaticInit,regular,pure_instructions";

clang/lib/Basic/Targets/OSTargets.cpp

if (Triple.isiOS()) {
     char Str[6];
     Str[0] = '0' + OsVersion.getMajor();
     Str[1] = '0' + (OsVersion.getMinor().getValueOr(0) / 10);
     Str[2] = '0' + (OsVersion.getMinor().getValueOr(0) % 10);
     Str[3] = '0' + (OsVersion.getSubminor().getValueOr(0) / 10);
     Str[4] = '0' + (OsVersion.getSubminor().getValueOr(0) % 10);
     Str[5] = '\0';
     Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
+  } else if (Triple.isDriverKit()) {
+    assert(OsVersion.getMajor() < 100 &&
+           OsVersion.getMinor().getValueOr(0) < 100 &&
+           OsVersion.getSubminor().getValueOr(0) < 100 && "Invalid version!");
+    char Str[7];
+    Str[0] = '0' + (OsVersion.getMajor() / 10);
+    Str[1] = '0' + (OsVersion.getMajor() % 10);
+    Str[2] = '0' + (OsVersion.getMinor().getValueOr(0) / 10);
+    Str[3] = '0' + (OsVersion.getMinor().getValueOr(0) % 10);
+    Str[4] = '0' + (OsVersion.getSubminor().getValueOr(0) / 10);
+    Str[5] = '0' + (OsVersion.getSubminor().getValueOr(0) % 10);
+    Str[6] = '\0';
+    Builder.defineMacro("__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__", Str);
   } else if (Triple.isMacOSX()) {
     // Note that the Driver allows versions which aren't representable in the
     // define (because we only get a single digit for the minor and micro
     // revision numbers). So, we limit them to the maximum representable
     // version.
     assert(OsVersion < VersionTuple(100) && "Invalid version!");
     char Str[7];
     if (OsVersion < VersionTuple(10, 10)) {

clang/lib/CodeGen/CGObjC.cpp

static unsigned getBaseMachOPlatformID(const llvm::Triple &TT) {
   case llvm::Triple::MacOSX:
     return llvm::MachO::PLATFORM_MACOS;
   case llvm::Triple::IOS:
     return llvm::MachO::PLATFORM_IOS;
   case llvm::Triple::TvOS:
     return llvm::MachO::PLATFORM_TVOS;
   case llvm::Triple::WatchOS:
     return llvm::MachO::PLATFORM_WATCHOS;
+  case llvm::Triple::DriverKit:
+    return llvm::MachO::PLATFORM_DRIVERKIT;
   default:
     return /*Unknown platform*/ 0;
   }
 }
 
 static llvm::Value *emitIsPlatformVersionAtLeast(CodeGenFunction &CGF,
                                                  const VersionTuple &Version) {
   CodeGenModule &CGM = CGF.CGM;
case llvm::Triple::TvOS:
     break;
   case llvm::Triple::WatchOS:
     FoundationDroppedInVersion = VersionTuple(/*Major=*/6);
     break;
   case llvm::Triple::Darwin:
   case llvm::Triple::MacOSX:
     FoundationDroppedInVersion = VersionTuple(/*Major=*/10, /*Minor=*/15);
     break;
+  case llvm::Triple::DriverKit:
+    // DriverKit doesn't need Foundation.
+    return false;
   default:
     llvm_unreachable("Unexpected OS");
   }
   return TargetVersion < FoundationDroppedInVersion;
 }
 
 void CodeGenModule::emitAtAvailableLinkGuard() {
   if (!IsPlatformVersionAtLeastFn)

clang/lib/Driver/Driver.cpp

if (!TC) {
     case llvm::Triple::CloudABI:
       TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
       break;
     case llvm::Triple::Darwin:
     case llvm::Triple::MacOSX:
     case llvm::Triple::IOS:
     case llvm::Triple::TvOS:
     case llvm::Triple::WatchOS:
+    case llvm::Triple::DriverKit:
       TC = std::make_unique<toolchains::DarwinClang>(*this, Target, Args);
       break;
     case llvm::Triple::DragonFly:
       TC = std::make_unique<toolchains::DragonFly>(*this, Target, Args);
       break;
     case llvm::Triple::OpenBSD:
       TC = std::make_unique<toolchains::OpenBSD>(*this, Target, Args);
       break;

clang/lib/Driver/ToolChain.cpp

static ToolChain::RTTIMode CalculateRTTIMode(const ArgList &Args,
   // Explicit rtti/no-rtti args
   if (CachedRTTIArg) {
     if (CachedRTTIArg->getOption().matches(options::OPT_frtti))
       return ToolChain::RM_Enabled;
     else
       return ToolChain::RM_Disabled;
   }
 
-  // -frtti is default, except for the PS4.
-  return (Triple.isPS4()) ? ToolChain::RM_Disabled : ToolChain::RM_Enabled;
+  // -frtti is default, except for the PS4 and DriverKit.
+  bool NoRTTI = Triple.isPS4() || Triple.isDriverKit();
+  return NoRTTI ? ToolChain::RM_Disabled : ToolChain::RM_Enabled;
 }
 
 ToolChain::ToolChain(const Driver &D, const llvm::Triple &T,
                      const ArgList &Args)
     : D(D), Triple(T), Args(Args), CachedRTTIArg(GetRTTIArgument(Args)),
       CachedRTTIMode(CalculateRTTIMode(Args, Triple, CachedRTTIArg)) {
   auto addIfExists = [this](path_list &List, const std::string &Path) {
     if (getVFS().exists(Path))

clang/lib/Driver/ToolChains/Arch/ARM.cpp

 
 arm::FloatABI arm::getDefaultFloatABI(const llvm::Triple &Triple) {
   auto SubArch = getARMSubArchVersionNumber(Triple);
   switch (Triple.getOS()) {
   case llvm::Triple::Darwin:
   case llvm::Triple::MacOSX:
   case llvm::Triple::IOS:
   case llvm::Triple::TvOS:
+  case llvm::Triple::DriverKit:
     // Darwin defaults to "softfp" for v6 and v7.
     if (Triple.isWatchABI())
       return FloatABI::Hard;
     else
       return (SubArch == 6 || SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
 
   case llvm::Triple::WatchOS:
     return FloatABI::Hard;

clang/lib/Driver/ToolChains/Arch/X86.cpp

std::string x86::getX86TargetCPU(const Driver &D, const ArgList &Args,
   // FIXME: Need target hooks.
   if (Triple.isOSDarwin()) {
     if (Triple.getArchName() == "x86_64h")
       return "core-avx2";
     // macosx10.12 drops support for all pre-Penryn Macs.
     // Simulators can still run on 10.11 though, like Xcode.
     if (Triple.isMacOSX() && !Triple.isOSVersionLT(10, 12))
       return "penryn";
+
+    if (Triple.isDriverKit())
+      return "nehalem";
+
     // The oldest x86_64 Macs have core2/Merom; the oldest x86 Macs have Yonah.
     return Is64Bit ? "core2" : "yonah";
   }
 
   // Set up default CPU name for PS4 compilers.
   if (Triple.isPS4())
     return "btver2";
 

clang/lib/Driver/ToolChains/Clang.cpp

if (types::isObjC(InputType) &&
                    options::OPT_fno_objc_exceptions, true)) {
     CmdArgs.push_back("-fobjc-exceptions");
 
     EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
   }
 
   if (types::isCXX(InputType)) {
     // Disable C++ EH by default on XCore and PS4.
-    bool CXXExceptionsEnabled =
-        Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4();
+    bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
+                                !Triple.isPS4() && !Triple.isDriverKit();
     Arg *ExceptionArg = Args.getLastArg(
         options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
         options::OPT_fexceptions, options::OPT_fno_exceptions);
     if (ExceptionArg)
       CXXExceptionsEnabled =
           ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
           ExceptionArg->getOption().matches(options::OPT_fexceptions);
 

clang/lib/Driver/ToolChains/CommonArgs.cpp

tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
   // instead.
   if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS4()))
     IsPICLevelTwo |= ToolChain.isPICDefault();
 
   // This kernel flags are a trump-card: they will disable PIC/PIE
   // generation, independent of the argument order.
   if (KernelOrKext &&
       ((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(6)) &&
-       !EffectiveTriple.isWatchOS()))
+       !EffectiveTriple.isWatchOS() && !EffectiveTriple.isDriverKit()))
     PIC = PIE = false;
 
   if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
     // This is a very special mode. It trumps the other modes, almost no one
     // uses it, and it isn't even valid on any OS but Darwin.
     if (!Triple.isOSDarwin())
       ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
           << A->getSpelling() << Triple.str();

clang/lib/Driver/ToolChains/Darwin.h

public:
   // the argument translation business.
   mutable bool TargetInitialized;
 
   enum DarwinPlatformKind {
     MacOS,
     IPhoneOS,
     TvOS,
     WatchOS,
-    LastDarwinPlatform = WatchOS
+    DriverKit,
+    LastDarwinPlatform = DriverKit
   };
   enum DarwinEnvironmentKind {
     NativeEnvironment,
     Simulator,
     MacCatalyst,
   };
 
   mutable DarwinPlatformKind TargetPlatform;
public:
   void addPlatformVersionArgs(const llvm::opt::ArgList &Args,
                               llvm::opt::ArgStringList &CmdArgs) const override;
 
   void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
                               llvm::opt::ArgStringList &CmdArgs) const override;
 
   bool isKernelStatic() const override {
     return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
-            !isTargetWatchOS());
+            !isTargetWatchOS() && !isTargetDriverKit());
   }
 
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
 
 protected:
   /// }
   /// @name Darwin specific Toolchain functions
bool isTargetWatchOSSimulator() const {
     return TargetPlatform == WatchOS && TargetEnvironment == Simulator;
   }
 
   bool isTargetWatchOSBased() const {
     assert(TargetInitialized && "Target not initialized!");
     return TargetPlatform == WatchOS;
   }
 
+  bool isTargetDriverKit() const {
+    assert(TargetInitialized && "Target not initialized!");
+    return TargetPlatform == DriverKit;
+  }
+
   bool isTargetMacCatalyst() const {
     return TargetPlatform == IPhoneOS && TargetEnvironment == MacCatalyst;
   }
 
   bool isTargetMacOS() const {
     assert(TargetInitialized && "Target not initialized!");
     return TargetPlatform == MacOS;
   }
bool UseObjCMixedDispatch() const override {
     // Mixed dispatch is used everywhere except OS X before 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())
+    if (isTargetIOSBased() || isTargetWatchOSBased() || isTargetDriverKit())
       return LangOptions::SSPOn;
     else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 6))
       return LangOptions::SSPOn;
     else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
       return LangOptions::SSPOn;
 
     return LangOptions::SSPOff;
   }

clang/lib/Driver/ToolChains/Darwin.cpp

if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
       if (A->getValue() == StringRef("Accelerate")) {
         CmdArgs.push_back("-framework");
         CmdArgs.push_back("Accelerate");
       }
     }
   }
 
+  // DriverKit's framework doesn't have the same layout as other frameworks.
+  // Add missing search paths if necessary.
+  if (getToolChain().getTriple().getOS() == llvm::Triple::DriverKit) {
+    if (const Arg *Root = Args.getLastArg(options::OPT_isysroot)) {
+      // ld64 fixed the implicit -F and -L paths in ld64-605.1+.
+      if (Version.getMajor() < 605 ||
+          (Version.getMajor() == 605 && Version.getMinor().getValueOr(0) < 1)) {
+
+        SmallString<128> L(Root->getValue());
+        llvm::sys::path::append(L, "System", "DriverKit", "usr", "lib");
+        CmdArgs.push_back(Args.MakeArgString(std::string("-L") + L));
+
+        SmallString<128> F(Root->getValue());
+        llvm::sys::path::append(F, "System", "DriverKit");
+        llvm::sys::path::append(F, "System", "Library", "Frameworks");
+        CmdArgs.push_back(Args.MakeArgString(std::string("-F") + F));
+      }
+    }
+  }
+
   ResponseFileSupport ResponseSupport;
   if (Version >= VersionTuple(705) || LinkerIsLLD) {
     ResponseSupport = ResponseFileSupport::AtFileUTF8();
   } else {
     // For older versions of the linker, use the legacy filelist method instead.
     ResponseSupport = {ResponseFileSupport::RF_FileList, llvm::sys::WEM_UTF8,
                        "-filelist"};
   }

 }
 
 bool MachO::HasNativeLLVMSupport() const { return true; }
 
 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
   // Default to use libc++ on OS X 10.9+ and iOS 7+.
   if ((isTargetMacOSBased() && !isMacosxVersionLT(10, 9)) ||
       (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
-      isTargetWatchOSBased())
+      isTargetWatchOSBased() || isTargetDriverKit())
     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())
+  if (isTargetWatchOSBased() || isTargetDriverKit())
     return true;
   else if (isTargetIOSBased())
     return !isIPhoneOSVersionLT(3, 2);
   else {
     assert(isTargetMacOSBased() && "unexpected darwin target");
     return !isMacosxVersionLT(10, 6);
   }
 }
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 (isTargetDriverKit())
+    Str += "driverkit";
   else if (isTargetIOSBased() || isTargetMacCatalyst())
     Str += "ios";
   else
     Str += "macosx";
   Str += getTripleTargetVersion().getAsString();
   Triple.setOSName(Str);
 
   return Triple.getTriple();
switch (TargetPlatform) {
     case DarwinPlatformKind::IPhoneOS:
       if (TargetEnvironment == MacCatalyst)
         return "MacOSX";
       return "iPhone";
     case DarwinPlatformKind::TvOS:
       return "AppleTV";
     case DarwinPlatformKind::WatchOS:
       return "Watch";
+    case DarwinPlatformKind::DriverKit:
+      return "DriverKit";
   }
   llvm_unreachable("Unsupported platform");
 }
 
 StringRef Darwin::getSDKName(StringRef isysroot) {
   // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
   auto BeginSDK = llvm::sys::path::rbegin(isysroot);
   auto EndSDK = llvm::sys::path::rend(isysroot);
case DarwinPlatformKind::IPhoneOS:
     return TargetEnvironment == NativeEnvironment || IgnoreSim ? "ios"
                                                                : "iossim";
   case DarwinPlatformKind::TvOS:
     return TargetEnvironment == NativeEnvironment || IgnoreSim ? "tvos"
                                                                : "tvossim";
   case DarwinPlatformKind::WatchOS:
     return TargetEnvironment == NativeEnvironment || IgnoreSim ? "watchos"
                                                                : "watchossim";
+  case DarwinPlatformKind::DriverKit:
+    return "driverkit";
   }
   llvm_unreachable("Unsupported platform");
 }
 
 /// Check if the link command contains a symbol export directive.
 static bool hasExportSymbolDirective(const ArgList &Args) {
   for (Arg *A : Args) {
     if (A->getOption().matches(options::OPT_exported__symbols__list))
void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
 
   const XRayArgs &XRay = getXRayArgs();
   if (XRay.needsXRayRt()) {
     AddLinkRuntimeLib(Args, CmdArgs, "xray");
     AddLinkRuntimeLib(Args, CmdArgs, "xray-basic");
     AddLinkRuntimeLib(Args, CmdArgs, "xray-fdr");
   }
 
+  if (isTargetDriverKit() && !Args.hasArg(options::OPT_nodriverkitlib)) {
+    CmdArgs.push_back("-framework");
+    CmdArgs.push_back("DriverKit");
+  }
+
   // Otherwise link libSystem, then the dynamic runtime library, and finally any
   // target specific static runtime library.
+  if (!isTargetDriverKit())
     CmdArgs.push_back("-lSystem");
 
   // Select the dynamic runtime library and the target specific static library.
   if (isTargetIOSBased()) {
     // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
     // it never went into the SDK.
     // Linking against libgcc_s.1 isn't needed for iOS 5.0+
     if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
         getTriple().getArch() != llvm::Triple::aarch64)
case DarwinPlatformKind::IPhoneOS:
       Opt = options::OPT_miphoneos_version_min_EQ;
       break;
     case DarwinPlatformKind::TvOS:
       Opt = options::OPT_mtvos_version_min_EQ;
       break;
     case DarwinPlatformKind::WatchOS:
       Opt = options::OPT_mwatchos_version_min_EQ;
       break;
+    case DarwinPlatformKind::DriverKit:
+      // DriverKit always explicitly provides a version in the triple.
+      return;
     }
     Argument = Args.MakeJoinedArg(nullptr, Opts.getOption(Opt), OSVersion);
     Args.append(Argument);
   }
 
   /// Returns the OS version with the argument / environment variable that
   /// specified it.
   std::string getAsString(DerivedArgList &Args, const OptTable &Opts) {
static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
     case llvm::Triple::MacOSX:
       return DarwinPlatformKind::MacOS;
     case llvm::Triple::IOS:
       return DarwinPlatformKind::IPhoneOS;
     case llvm::Triple::TvOS:
       return DarwinPlatformKind::TvOS;
     case llvm::Triple::WatchOS:
       return DarwinPlatformKind::WatchOS;
+    case llvm::Triple::DriverKit:
+      return DarwinPlatformKind::DriverKit;
     default:
       llvm_unreachable("Unable to infer Darwin variant");
     }
   }
 
   SourceKind Kind;
   DarwinPlatformKind Platform;
   DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;

 
 /// Returns the deployment target that's specified using the
 /// OS_DEPLOYMENT_TARGET environment variable.
 Optional<DarwinPlatform>
 getDeploymentTargetFromEnvironmentVariables(const Driver &TheDriver,
                                             const llvm::Triple &Triple) {
   std::string Targets[Darwin::LastDarwinPlatform + 1];
   const char *EnvVars[] = {
       "MACOSX_DEPLOYMENT_TARGET",
       "IPHONEOS_DEPLOYMENT_TARGET",
       "TVOS_DEPLOYMENT_TARGET",
       "WATCHOS_DEPLOYMENT_TARGET",
+      "DRIVERKIT_DEPLOYMENT_TARGET",
   };
   static_assert(llvm::array_lengthof(EnvVars) == Darwin::LastDarwinPlatform + 1,
                 "Missing platform");
   for (const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
     if (char *Env = ::getenv(I.value()))
       Targets[I.index()] = Env;
   }
 
auto CreatePlatformFromSDKName =
     else if (SDK.startswith("WatchOS") || SDK.startswith("WatchSimulator"))
       return DarwinPlatform::createFromSDK(
           Darwin::WatchOS, Version,
           /*IsSimulator=*/SDK.startswith("WatchSimulator"));
     else if (SDK.startswith("AppleTVOS") || SDK.startswith("AppleTVSimulator"))
       return DarwinPlatform::createFromSDK(
           Darwin::TvOS, Version,
           /*IsSimulator=*/SDK.startswith("AppleTVSimulator"));
+    else if (SDK.startswith("DriverKit"))
+      return DarwinPlatform::createFromSDK(Darwin::DriverKit, Version);
     return None;
   };
   if (auto Result = CreatePlatformFromSDKName(SDK))
     return Result;
   // The SDK can be an SDK variant with a name like `<prefix>.<platform>`.
   return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
 }
 
if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
       OsVersion = Triple.getiOSVersion();
     break;
   case llvm::Triple::TvOS:
     OsVersion = Triple.getOSVersion();
     break;
   case llvm::Triple::WatchOS:
     OsVersion = Triple.getWatchOSVersion();
     break;
+  case llvm::Triple::DriverKit:
+    OsVersion = Triple.getDriverKitVersion();
+    break;
   default:
     llvm_unreachable("Unexpected OS type");
     break;
   }
 
   std::string OSVersion;
   llvm::raw_string_ostream(OSVersion)
       << OsVersion.getMajor() << '.' << OsVersion.getMinor().getValueOr(0)
if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << OSTarget->getAsString(Args, Opts);
   } else if (Platform == WatchOS) {
     if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
                                    Micro, HadExtra) ||
         HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << OSTarget->getAsString(Args, Opts);
+  } else if (Platform == DriverKit) {
+    if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
+                                   Micro, HadExtra) ||
+        HadExtra || Major < 19 || Major >= 100 || Minor >= 100 || Micro >= 100)
+      getDriver().Diag(diag::err_drv_invalid_version_number)
+          << OSTarget->getAsString(Args, Opts);
   } else
     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())
+      Platform != DriverKit && OSTarget->canInferSimulatorFromArch() &&
+      getTriple().isX86())
     Environment = Simulator;
 
   VersionTuple NativeTargetVersion;
   if (Environment == MacCatalyst)
     NativeTargetVersion = OSTarget->getNativeTargetVersion();
   setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
   TargetVariantTriple = OSTarget->getTargetVariantTriple();
 
void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
 
   // Use the newer cc_kext for iOS ARM after 6.0.
   if (isTargetWatchOS()) {
     llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
   } else if (isTargetTvOS()) {
     llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
   } else if (isTargetIPhoneOS()) {
     llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
+  } else if (isTargetDriverKit()) {
+    // DriverKit doesn't want extra runtime support.
   } else {
     llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
   }
 
   // For now, allow missing resource libraries to support developers who may
   // not have compiler-rt checked out or integrated into their build.
   if (getVFS().exists(P))
     CmdArgs.push_back(Args.MakeArgString(P));
case IPhoneOS:
     OS = llvm::Triple::IOS;
     break;
   case TvOS: // Earlier than 11.0.
     OS = llvm::Triple::TvOS;
     break;
   case WatchOS: // Earlier than 4.0.
     OS = llvm::Triple::WatchOS;
     break;
+  case DriverKit: // Always available.
+    return false;
   }
 
   return TargetVersion < alignedAllocMinVersion(OS);
 }
 
 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
                                    llvm::opt::ArgStringList &CC1Args,
                                    Action::OffloadKind DeviceOffloadKind) const {
Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
   // after argument translation because -Xarch_ arguments may add a version min
   // argument.
   AddDeploymentTarget(*DAL);
 
   // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
   // FIXME: It would be far better to avoid inserting those -static arguments,
   // but we can't check the deployment target in the translation code until
   // it is set here.
-  if (isTargetWatchOSBased() ||
+  if (isTargetWatchOSBased() || isTargetDriverKit() ||
       (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
     for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
       Arg *A = *it;
       ++it;
       if (A->getOption().getID() != options::OPT_mkernel &&
           A->getOption().getID() != options::OPT_fapple_kext)
         continue;
       assert(it != ie && "unexpected argument translation");
void Darwin::addMinVersionArgs(const ArgList &Args,
   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 (isTargetDriverKit())
+    CmdArgs.push_back("-driverkit_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");
static const char *getPlatformName(Darwin::DarwinPlatformKind Platform,
   case Darwin::IPhoneOS:
     if (Environment == Darwin::MacCatalyst)
       return "mac catalyst";
     return "ios";
   case Darwin::TvOS:
     return "tvos";
   case Darwin::WatchOS:
     return "watchos";
+  case Darwin::DriverKit:
+    return "driverkit";
   }
   llvm_unreachable("invalid platform");
 }
 
 void Darwin::addPlatformVersionArgs(const llvm::opt::ArgList &Args,
                                     llvm::opt::ArgStringList &CmdArgs) const {
   auto EmitPlatformVersionArg =
       [&](const VersionTuple &TV, Darwin::DarwinPlatformKind TargetPlatform,

clang/lib/Frontend/CompilerInvocation.cpp

#else
       LangStd = LangStandard::lang_gnu11;
 #endif
       break;
     case Language::CXX:
     case Language::ObjCXX:
 #if defined(CLANG_DEFAULT_STD_CXX)
       LangStd = CLANG_DEFAULT_STD_CXX;
 #else
+      if (T.isDriverKit())
+        LangStd = LangStandard::lang_gnucxx17;
+      else
         LangStd = LangStandard::lang_gnucxx14;
 #endif
       break;
     case Language::RenderScript:
       LangStd = LangStandard::lang_c99;
       break;
     case Language::HIP:
       LangStd = LangStandard::lang_hip;
       break;

clang/test/Analysis/driverkit_base.h

+#ifndef _DRIVERKIT_BASE
+#define _DRIVERKIT_BASE
+
+using OSObjectPtr = OSObject *;
+
+void OSObjectRetain(OSObjectPtr container);
+void OSObjectRelease(OSObjectPtr container);
+
+#define OSObjectSafeReleaseNULL(ptr) \
+  do {                               \
+    if ((ptr)) {                     \
+      OSObjectRelease(ptr);          \
+      (ptr) = NULL;                  \
+    }                                \
+  } while (0)
+
+class OSDictionary : public OSObject {};
+using OSDictionaryPtr = OSDictionary *;
+OSDictionaryPtr OSDictionaryCreate();
+OSObjectPtr OSDictionaryGetValue(OSDictionaryPtr obj, const char *key);
+
+#endif // _DRIVERKIT_BASE

clang/test/Analysis/retain-release-driverkit.cpp

+// RUN: %clang_analyze_cc1 -w -triple x86_64-apple-driverkit19.0 \
+// RUN:   -analyzer-checker=core,osx -verify %s
+
+#include "os_object_base.h"
+#include "driverkit_base.h"
+
+typedef kern_return_t IOReturn;
+#define kIOReturnSuccess 0
+
+void test_driverkit_naming_conventions(OSDictionary *Dict) {
+  OSDictionaryGetValue(Dict, "key"); // no-warning
+  OSDictionaryPtr Dict2 = OSDictionaryCreate(); // expected-warning{{Potential leak of an object stored into 'Dict2'}}
+}
+
+void test_driverkit_retain_release() {
+  OSDictionaryPtr Dict = OSDictionaryCreate();
+  OSObjectRetain(Dict);
+  OSObjectRelease(Dict);
+  OSObjectRelease(Dict);
+}
+
+IOReturn make_out_param_and_ioreturn(OSObject **obj);
+OSObject *make_out_param_and_osobject(OSObject **obj);
+bool make_out_param_and_bool(OSObject **obj);
+void just_make_out_param(OSObject **obj);
+void get_out_param(OSObject **obj);
+void get_out_param_annotated(__attribute__((os_returns_retained)) OSObject **obj);
+IOReturn get_out_param_and_ioreturn(OSObject **obj);
+
+void test_out_param_conventions() {
+  OSObject *Obj = nullptr;
+  // Don't warn when the function returned a failure.
+  IOReturn ret = make_out_param_and_ioreturn(&Obj); // no-warning
+  if (ret == kIOReturnSuccess)
+    OSObjectRelease(Obj);
+
+  // Warn if the return value is unchecked.
+  make_out_param_and_ioreturn(&Obj); // expected-warning{{Potential leak of an object stored into 'Obj'}}
+
+  // If it looks like a getter, treat it as +0.
+  OSObject *Obj2;
+  ret = get_out_param_and_ioreturn(&Obj2);
+  if (ret == kIOReturnSuccess)
+    OSObjectRelease(Obj2); // expected-warning{{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}}
+
+  // Treat "true" as success, "false" as failure by default.
+  bool b = make_out_param_and_bool(&Obj2); // no-warning
+  if (b)
+    OSObjectRelease(Obj2);
+
+  // Warn only when the object that was returned directly
+  // has turned out to be valid (or nobody cared).
+  OSObject *Obj3; // Let's also see what happens if it's uninitialized.
+  OSObject *Obj4 = make_out_param_and_osobject(&Obj3); // no-warning
+  if (Obj4) {
+    OSObjectRelease(Obj3); // no-warning
+    OSObjectRelease(Obj4); // no-warning
+  }
+
+  make_out_param_and_osobject(&Obj3); // expected-warning{{Potential leak of an object of type 'OSObject'}}
+                                      // expected-warning@-1{{Potential leak of an object stored into 'Obj3'}}
+
+  // When there's no return value, always treat it as +1...
+  OSObject *Obj5 = nullptr;
+  just_make_out_param(&Obj5); // expected-warning{{Potential leak of an object stored into 'Obj5'}}
+
+  // ...unless it looks like a getter, in this case treat it as +0.
+  OSObject *Obj6 = nullptr;
+  get_out_param(&Obj6); // no-warning
+  if (Obj6)
+    OSObjectRelease(Obj6); // expected-warning{{Incorrect decrement of the reference count of an object that is not owned at this point by the caller}}
+
+  OSObject *Obj7 = nullptr;
+  get_out_param_annotated(&Obj7);
+  OSObjectRelease(Obj7); // no-warning
+}

clang/test/CodeGen/availability-check-driverkit.c

+// RUN: %clang_cc1 -triple x86_64-apple-driverkit19.0 -emit-llvm -o - %s | FileCheck %s
+
+void use_at_available() {
+  // CHECK: call i32 @__isPlatformVersionAtLeast(i32 10, i32 19, i32 1, i32 0)
+  // CHECK-NEXT: icmp ne
+  if (__builtin_available(driverkit 19.1, *))
+    ;
+}
+
+// CHECK: declare i32 @__isPlatformVersionAtLeast(i32, i32, i32, i32)

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

+// RUN: touch %t.o
+
+// RUN: %clang -target x86_64-apple-driverkit10.15 -isysroot %S/Inputs/MacOSX10.14.sdk -mlinker-version=520 -### %t.o 2>&1 \
+// RUN:   | FileCheck %s
+// RUN: mkdir -p %t.sdk
+// RUN: %clang -target x86_64-apple-driverkit19 -isysroot %t.sdk -mlinker-version=520 -### %t.o 2>&1 \
+// RUN:   | FileCheck --check-prefix=MISSING-SDK-JSON-WORKAROUND %s
+
+// RUN: %clang -target arm64-apple-driverkit19 -isysroot %S/Inputs/MacOSX10.14.sdk -mlinker-version=520 -### %t.o 2>&1 \
+// RUN:   | FileCheck --check-prefix=ARM64_NEW %s
+// RUN: %clang -target arm64-apple-driverkit19 -isysroot %S/Inputs/MacOSX10.14.sdk -mlinker-version=400 -### %t.o 2>&1 \
+// RUN:   | FileCheck --check-prefix=ARM64_OLD %s
+// RUN: %clang -target arm64e-apple-driverkit19 -isysroot %S/Inputs/MacOSX10.14.sdk -mlinker-version=520 -### %t.o 2>&1 \
+// RUN:   | FileCheck --check-prefix=ARM64_NEW %s
+
+// CHECK: "-platform_version" "driverkit" "10.15.0" "10.14"
+// MISSING-SDK-JSON-WORKAROUND: "-platform_version" "driverkit" "19.0.0" "19.0.0"
+
+// ARM64_NEW: "-platform_version" "driverkit" "20.0.0" "10.14"
+// ARM64_OLD: "-driverkit_version_min" "20.0.0"

clang/test/Driver/darwin-ld.c

 // LINK_TVOS_PROFILE: libclang_rt.tvos.a
 
 // RUN: %clang -target arm64-apple-tvos8.3 -fuse-ld= -mlinker-version=400 -mtvos-version-min=8.3 -resource-dir=%S/Inputs/resource_dir -### %t.o -lcc_kext 2> %t.log
 // RUN: FileCheck -check-prefix=LINK_TVOS_KEXT %s < %t.log
 // LINK_TVOS_KEXT: {{ld(.exe)?"}}
 // LINK_TVOS_KEXT: libclang_rt.cc_kext_tvos.a
 // LINK_TVOS_KEXT: libclang_rt.tvos.a
 
+// RUN: %clang -target x86-64-apple-driverkit19.0 -mlinker-version=400 -resource-dir=%S/Inputs/resource_dir -### %t.o 2> %t.log
+// RUN: FileCheck -check-prefix=LINK_DRIVERKIT %s < %t.log
+// LINK_DRIVERKIT: {{ld(.exe)?"}}
+// LINK_DRIVERKIT: -driverkit_version_min
+// LINK_DRIVERKIT-NOT: crt
+// LINK_DRIVERKIT-NOT: lgcc_s.1
+// LINK_DRIVERKIT-NOT: lSystem
+// LINK_DRIVERKIT: libclang_rt.driverkit.a
+
 // RUN: %clang -target armv7k-apple-watchos2.0 -fuse-ld= -mlinker-version=400 -mwatchos-version-min=2.0 -resource-dir=%S/Inputs/resource_dir -### %t.o 2> %t.log
 // RUN: FileCheck -check-prefix=LINK_WATCHOS_ARM %s < %t.log
 // LINK_WATCHOS_ARM: {{ld(.exe)?"}}
 // LINK_WATCHOS_ARM: -watchos_version_min
 // LINK_WATCHOS_ARM-NOT: crt
 // LINK_WATCHOS_ARM-NOT: lgcc_s.1
 // LINK_WATCHOS_ARM: libclang_rt.watchos.a
 

clang/test/Driver/darwin-version.c

 // CHECK-VERSION-TVSIM83: "i386-apple-tvos8.3.0-simulator"
 // RUN: %clang -target armv7k-apple-darwin -mwatchos-version-min=2.0 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-WATCHOS20 %s
 // CHECK-VERSION-WATCHOS20: "thumbv7k-apple-watchos2.0.0"
 // RUN: %clang -target i386-apple-darwin -mwatchos-simulator-version-min=2.0 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-WATCHSIM20 %s
 // CHECK-VERSION-WATCHSIM20: "i386-apple-watchos2.0.0-simulator"
 
+// RUN: %clang -target x86_64-apple-driverkit19.0 -c %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-VERSION-DRIVERKIT190 %s
+// CHECK-VERSION-DRIVERKIT190: "x86_64-apple-driverkit19.0.0"
+
 // Check environment variable gets interpreted correctly
 // RUN: env MACOSX_DEPLOYMENT_TARGET=10.5 IPHONEOS_DEPLOYMENT_TARGET=2.0 \
 // RUN:   %clang -target i686-apple-darwin9 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-OSX5 %s
 // RUN: env MACOSX_DEPLOYMENT_TARGET=10.5 IPHONEOS_DEPLOYMENT_TARGET=2.0 \
 // RUN:   %clang -target armv6-apple-darwin9 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-IOS2 %s
 

 // RUN: %clang -target x86_64-apple-tvos11.0 -c %s -### 2>&1 | \
 // RUN: FileCheck --check-prefix=CHECK-VERSION-TVOS-TARGET %s
 // CHECK-VERSION-TVOS-TARGET: "x86_64-apple-tvos11.0.0-simulator"
 
 // RUN: %clang -target x86_64-apple-watchos4.0 -c %s -### 2>&1 | \
 // RUN: FileCheck --check-prefix=CHECK-VERSION-WATCHOS-TARGET %s
 // CHECK-VERSION-WATCHOS-TARGET: "x86_64-apple-watchos4.0.0-simulator"
 
+// RUN: env DRIVERKIT_DEPLOYMENT_TARGET=19.0 \
+// RUN:   %clang -target x86_64-apple-darwin -c %s -### 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-VERSION-DRIVERKIT %s
+// CHECK-VERSION-DRIVERKIT: "x86_64-apple-driverkit19.0.0"
+//
+// Make sure stdlib is not mistaken
+// RUN: env DRIVERKIT_DEPLOYMENT_TARGET=2.0 \
+// RUN:   %clang -target arm64-apple-darwin -c -x c++ %s -stdlib=libc++ -### 2>&1
+
 // RUN: env MACOSX_DEPLOYMENT_TARGET=1000.1000 \
 // RUN:   %clang -target x86_64-apple-darwin -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-INVALID-ENV %s
 // CHECK-VERSION-INVALID-ENV: invalid version number in 'MACOSX_DEPLOYMENT_TARGET=1000.1000'
 
 
 
 // Target can specify the OS version:

clang/test/Driver/debug-options.c

 // RUN: %clang -### -c -g %s -target armv7-apple-ios8.0 2>&1 \
 // RUN:             | FileCheck -check-prefix=G_ONLY_DWARF2 %s
 // RUN: %clang -### -c -g %s -target armv7k-apple-watchos 2>&1 \
 // RUN:             | FileCheck -check-prefix=G_STANDALONE \
 // RUN:                         -check-prefix=G_DWARF4 %s
 // RUN: %clang -### -c -g %s -target arm64-apple-tvos9.0 2>&1 \
 // RUN:             | FileCheck -check-prefix=G_STANDALONE \
 // RUN:                         -check-prefix=G_DWARF4 %s
+// RUN: %clang -### -c -g %s -target x86_64-apple-driverkit19.0 2>&1 \
+// RUN:             | FileCheck -check-prefix=G_STANDALONE \
+// RUN:                         -check-prefix=G_DWARF4 %s
 // RUN: %clang -### -c -fsave-optimization-record %s \
 // RUN:        -target x86_64-apple-darwin 2>&1 \
 // RUN:             | FileCheck -check-prefix=GLTO_ONLY %s
 // RUN: %clang -### -c -g -fsave-optimization-record %s \
 // RUN:        -target x86_64-apple-darwin 2>&1 \
 // RUN:             | FileCheck -check-prefix=G_STANDALONE %s
 
 // FreeBSD.

clang/test/Driver/driverkit-arm64.c

+// REQUIRES: aarch64-registered-target
+// RUN: %clang %s -target arm64-apple-driverkit -### 2>&1 | FileCheck %s
+
+// CHECK: "-target-cpu" "apple-a7"

clang/test/Driver/driverkit-arm64e.c

+// REQUIRES: aarch64-registered-target
+// RUN: %clang %s -target arm64e-apple-driverkit -### 2>&1 | FileCheck %s
+
+// CHECK: "-target-cpu" "apple-a12"

clang/test/Driver/driverkit-armv7k.s

+// RUN: %clang -c -x assembler-with-cpp -target armv7k-apple-driverkit21.0 -### %s 2>&1 | FileCheck %s
+// CHECK: -cc1as
+// CHECK-SAME: "-target-cpu" "cortex-a7"
+.foo:
+vfms.f64 d1, d0, d3
 No newline at end of file

clang/test/Driver/driverkit-cplusplus.cpp

+// REQUIRES: x86-registered-target
+// RUN: %clang %s -target x86_64-apple-driverkit19.0 -fsyntax-only
+
+#if __cplusplus != 201703L
+#error DriverKit should be on C++17.
+#endif
+
+int main() { return 0; }

clang/test/Driver/driverkit-exceptions.cpp

+// REQUIRES: x86-registered-target
+// RUN: %clang %s -target x86_64-apple-driverkit19.0 -### 2>&1 | FileCheck %s -check-prefix=DEFAULT
+// RUN: %clang %s -target x86_64-apple-driverkit19.0 -fexceptions -### 2>&1 | FileCheck %s -check-prefix=USERPROVIDED
+
+int main() { return 0; }
+// DEFAULT-NOT: "-fcxx-exceptions"
+// DEFAULT-NOT: "-fexceptions"
+// USERPROVIDED: "-fcxx-exceptions"
+// USERPROVIDED: "-fexceptions"

clang/test/Driver/driverkit-framework.c

+// RUN: %clang %s -target x86_64-apple-driverkit19.0 \
+// RUN:   -isysroot %S/Inputs/DriverKit19.0.sdk -### 2>&1 \
+// RUN: | FileCheck %s -check-prefix=CHECK-DEFAULT
+
+// RUN: %clang %s -target x86_64-apple-driverkit19.0 -nodriverkitlib \
+// RUN:   -isysroot %S/Inputs/DriverKit19.0.sdk -### 2>&1 \
+// RUN: | FileCheck %s -check-prefix=CHECK-NO-DRIVERKIT
+
+int main() { return 0; }
+
+// CHECK-DEFAULT: "-framework" "DriverKit"
+
+// CHECK-NO-DRIVERKIT-NOT: "-framework" "DriverKit"

clang/test/Driver/driverkit-rtti.cpp

+// REQUIRES: x86-registered-target
+// RUN: %clang %s -target x86_64-apple-driverkit19.0 -### 2>&1 | FileCheck %s
+
+int main() { return 0; }
+// CHECK: "-fno-rtti"

clang/test/Driver/driverkit-target-cpu.c

+// REQUIRES: x86-registered-target
+// RUN: %clang %s -target x86_64-apple-driverkit19.0 -### 2>&1 | FileCheck %s
+
+int main() { return 0; }
+// CHECK: "-target-cpu" "nehalem"

clang/test/Driver/driverkit-version-min.c

+// REQUIRES: x86-registered-target
+// RUN: %clang -target x86_64-apple-driverkit19.0 -S -o - %s | FileCheck %s
+
+int main() { return 0; }
+// CHECK: .build_version driverkit, 19, 0

clang/test/Driver/incompatible_sysroot.c

 // REQUIRES: x86-registered-target
 // REQUIRES: aarch64-registered-target
 
 // RUN: %clang -target x86_64-apple-darwin -Wincompatible-sysroot -isysroot SDKs/MacOSX10.9.sdk -mios-version-min=9.0 -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-OSX-IOS %s
 // RUN: %clang -target arm64-apple-darwin -Wincompatible-sysroot -isysroot SDKs/iPhoneOS9.2.sdk -mwatchos-version-min=2.0 -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-IOS-WATCHOS %s
 // RUN: %clang -target arm64-apple-darwin -Wincompatible-sysroot -isysroot SDKs/iPhoneOS9.2.sdk -mtvos-version-min=9.0 -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-IOS-TVOS %s
+// RUN: %clang -target x86_64-apple-driverkit19.0 -Wincompatible-sysroot -isysroot SDKs/MacOSX10.9.sdk -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-OSX-DRIVERKIT %s
+// RUN: %clang -target x86_64-apple-driverkit19.0 -Wincompatible-sysroot -isysroot SDKs/iPhoneOS9.2.sdk -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-IOS-DRIVERKIT %s
 // RUN: %clang -target x86_64-apple-darwin -Wincompatible-sysroot -isysroot SDKs/iPhoneSimulator9.2.sdk -mios-version-min=9.0 -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-IOS-IOSSIM %s
 // RUN: %clang -target x86_64-apple-darwin -Wno-incompatible-sysroot -isysroot SDKs/MacOSX10.9.sdk -mios-version-min=9.0 -S -o - %s 2>&1 | FileCheck -check-prefix CHECK-OSX-IOS-DISABLED %s
 
 int main() { return 0; }
 // CHECK-OSX-IOS: warning: using sysroot for 'MacOSX' but targeting 'iPhone'
 // CHECK-IOS-WATCHOS: warning: using sysroot for 'iPhoneOS' but targeting 'Watch'
 // CHECK-IOS-TVOS: warning: using sysroot for 'iPhoneOS' but targeting 'AppleTV'
+// CHECK-OSX-DRIVERKIT: warning: using sysroot for 'MacOSX' but targeting 'DriverKit'
+// CHECK-IOS-DRIVERKIT: warning: using sysroot for 'iPhoneOS' but targeting 'DriverKit'
 // CHECK-IOS-IOSSIM-NOT: warning: using sysroot for '{{.*}}' but targeting '{{.*}}'
 // CHECK-OSX-IOS-DISABLED-NOT: warning: using sysroot for '{{.*}}' but targeting '{{.*}}'

clang/test/Driver/instrprof-ld.c

 // RUN:     -target armv7s-apple-darwin10 -mwatchos-version-min=2.0 -arch armv7k -fprofile-instr-generate -fuse-ld=ld \
 // RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:   | FileCheck --check-prefix=CHECK-WATCHOS-ARMV7 %s
 //
 // CHECK-WATCHOS-ARMV7: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
 // CHECK-WATCHOS-ARMV7: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}darwin{{/|\\\\}}libclang_rt.profile_watchos.a"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -target x86_64-apple-driverkit19.0 -arch x86_64 -fprofile-instr-generate -fuse-ld=ld \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
+// RUN:   | FileCheck --check-prefix=CHECK-DRIVERKIT-X86_64 %s
+//
+// CHECK-DRIVERKIT-X86_64: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
+// CHECK-DRIVERKIT-X86_64: "{{.*}}/Inputs/resource_dir{{/|\\\\}}lib{{/|\\\\}}darwin{{/|\\\\}}libclang_rt.profile_driverkit.a"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target i386-pc-win32 -fprofile-instr-generate \
 // RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:   | FileCheck --check-prefix=CHECK-WINDOWS-I386 %s
 //
 // CHECK-WINDOWS-I386: "{{.*}}link{{(.exe)?}}"
 // CHECK-WINDOWS-I386: "{{.*}}clang_rt.profile{{(-i386)?}}.lib"
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \

clang/test/Driver/pic.c

 // RUN: %clang -c %s -target armv7-apple-ios6 -mkernel -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-PIC2
 // RUN: %clang -c %s -target arm64-apple-ios7 -mkernel -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-PIC2
 // RUN: %clang -x assembler -c %s -target arm64-apple-ios7 -mkernel -no-integrated-as -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-NO-STATIC
 // RUN: %clang -c %s -target armv7k-apple-watchos1 -fapple-kext -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-PIC2
+// RUN: %clang -c %s -target x86_64-apple-driverkit -fapple-kext -### 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-PIC2
 // RUN: %clang -c %s -target armv7-apple-ios5 -fapple-kext -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-NO-PIC
 // RUN: %clang -c %s -target armv7-apple-ios6 -fapple-kext -static -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-NO-PIC
 // RUN: %clang -c %s -target armv7-apple-unknown-macho -static -### 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-NO-PIC
 //
 // On OpenBSD, PIE is enabled by default, but can be disabled.

clang/test/Driver/stack-protector.c

 // SSP-PS4-BUF: "-stack-protector" "2"
 // SSP-PS4-BUF: "-stack-protector-buffer-size" "16"
 
 // Test default stack protector values for Darwin platforms
 
 // RUN: %clang -target armv7k-apple-watchos2.0 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_WATCHOS
 // RUN: %clang -ffreestanding -target armv7k-apple-watchos2.0 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_WATCHOS
 // SSP_WATCHOS: "-stack-protector" "1"
+// RUN: %clang -target x86_64-apple-driverkit19.0 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_DRIVERKIT
+// SSP_DRIVERKIT: "-stack-protector" "1"
 // RUN: %clang -target arm64-apple-ios8.0.0 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_IOS
 // RUN: %clang -ffreestanding -target arm64-apple-ios8.0.0 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_IOS
 // SSP_IOS: "-stack-protector" "1"
 // RUN: %clang -target x86_64-apple-darwin10 -mmacosx-version-min=10.6 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX
 // RUN: %clang -ffreestanding -target x86_64-apple-darwin10 -mmacosx-version-min=10.6 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX
 // SSP_MACOSX: "-stack-protector" "1"
 // RUN: %clang -target x86_64-apple-darwin10 -mmacosx-version-min=10.5 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX_10_5
 // RUN: %clang -ffreestanding -target x86_64-apple-darwin10 -mmacosx-version-min=10.5 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX_10_5
 // SSP_MACOSX_10_5: "-stack-protector" "1"
 // RUN: %clang -target x86_64-apple-darwin10 -mmacosx-version-min=10.5 -mkernel -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX_KERNEL
 // SSP_MACOSX_KERNEL-NOT: "-stack-protector"
 // RUN: %clang -target x86_64-apple-darwin10 -mmacosx-version-min=10.6 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX_10_6_KERNEL
 // RUN: %clang -ffreestanding -target x86_64-apple-darwin10 -mmacosx-version-min=10.6 -### %s 2>&1 | FileCheck %s -check-prefix=SSP_MACOSX_10_6_KERNEL
 // SSP_MACOSX_10_6_KERNEL: "-stack-protector" "1"
 

clang/test/Frontend/darwin-version.c

 // RUN: grep '__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__' %t | grep '20100' | count 1
 // RUN: not grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t
 // RUN: not grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t
 
 // RUN: %clang_cc1 -triple i386-apple-watchos2.1 -dM -E -o %t %s
 // RUN: grep '__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__' %t | grep '20100' | count 1
 // RUN: not grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t
 // RUN: not grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t
+
+// RUN: %clang_cc1 -triple x86_64-apple-driverkit19.0 -dM -E -o %t %s
+// RUN: grep '__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__' %t | grep '1900' | count 1
+// RUN: not grep '__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__' %t
+// RUN: not grep '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__' %t

clang/test/Preprocessor/arm-target-features.c

 
 // RUN: %clang -target armv8.2a-none-none-eabi -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-V82A %s
 // CHECK-V82A: #define __ARM_ARCH 8
 // CHECK-V82A: #define __ARM_ARCH_8_2A__ 1
 // CHECK-V82A: #define __ARM_ARCH_PROFILE 'A'
 // CHECK-V82A: #define __ARM_FEATURE_QRDMX 1
 // CHECK-V82A: #define __ARM_FP 0xe
 
+// RUN: %clang -target armv7-apple-driverkit21.0 -x c %s -dM -E -o - | FileCheck -match-full-lines --check-prefix=CHECK-DRIVERKIT %s
+// CHECK-DRIVERKIT-NOT: #define __ARM_PCS_VFP 1
+
 // RUN: %clang -target armv8.3a-none-none-eabi -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-V83A %s
 // CHECK-V83A: #define __ARM_ARCH 8
 // CHECK-V83A: #define __ARM_ARCH_8_3A__ 1
 // CHECK-V83A: #define __ARM_ARCH_PROFILE 'A'
 
 // RUN: %clang -target armv8.4a-none-none-eabi -x c -E -dM %s -o - | FileCheck -match-full-lines --check-prefix=CHECK-V84A %s
 // CHECK-V84A: #define __ARM_ARCH 8
 // CHECK-V84A: #define __ARM_ARCH_8_4A__ 1

clang/test/Sema/attr-availability-driverkit.c

+// RUN: %clang_cc1 "-triple" "x86_64-apple-driverkit20.0" -fsyntax-only -verify %s
+
+void f0(int) __attribute__((availability(driverkit,introduced=19.0,deprecated=20.0))); // expected-note {{'f0' has been explicitly marked deprecated here}}
+void f1(int) __attribute__((availability(driverkit,introduced=20.0)));
+void f2(int) __attribute__((availability(driverkit,introduced=19.0,deprecated=20.0))); // expected-note {{'f2' has been explicitly marked deprecated here}}
+void f3(int) __attribute__((availability(driverkit,introduced=20.0)));
+void f4(int) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,obsoleted=10.5), availability(driverkit,introduced=19.0,deprecated=19.5,obsoleted=20.0))); // expected-note{{explicitly marked unavailable}}
+
+void f5(int) __attribute__((availability(driverkit,introduced=19.0))) __attribute__((availability(driverkit,deprecated=20.0))); // expected-note {{'f5' has been explicitly marked deprecated here}}
+void f6(int) __attribute__((availability(driverkit,deprecated=20.0))); // expected-note {{'f6' has been explicitly marked deprecated here}}
+void f7(int) __attribute__((availability(driverkit,introduced=19.0)));
+
+void test() {
+  f0(0); // expected-warning{{'f0' is deprecated: first deprecated in DriverKit 20.0}}
+  f1(0);
+  f2(0); // expected-warning{{'f2' is deprecated: first deprecated in DriverKit 20.0}}
+  f3(0);
+  f4(0); // expected-error{{f4' is unavailable: obsoleted in DriverKit 20.0}}
+  f5(0); // expected-warning{{'f5' is deprecated: first deprecated in DriverKit 20.0}}
+  f6(0); // expected-warning{{'f6' is deprecated: first deprecated in DriverKit 20.0}}
+  f7(0);
+}