[clang] Add __is_target_variant_{os,environment} builtins

[thakis]

Summary

Xcode 13's clang has them. For the included testcase, Xcode's clang
behaves like the implementation in this patch.

Availability.h in the macOS 12.0 SDK (part of Xcode 13, and the current
stable version of the macOS SDK) does something like:

#if defined(__has_builtin)
  ...
  #if __has_builtin(__is_target_os)
   #if __has_builtin(__is_target_environment)
    #if __has_builtin(__is_target_variant_os)
     #if __has_builtin(__is_target_variant_environment)
      #if (... && ((__is_target_os(ios) && __is_target_environment(macabi)) || (__is_target_variant_os(ios) && __is_target_variant_environment(macabi))))
        #define __OSX_AVAILABLE_STARTING(_osx, _ios) ...
        #define __OSX_AVAILABLE_BUT_DEPRECATED(_osxIntro, _osxDep, _iosIntro, _iosDep) ...
        #define __OSX_AVAILABLE_BUT_DEPRECATED_MSG(_osxIntro, _osxDep, _iosIntro, _iosDep, _msg) ...

So if has_builtin(is_target_variant_os) or
has_builtin(is_target_variant_environment) are false, these defines are not
defined.

Most of the time, this doesn't matter. But open-source clang currently fails
to commpile a file containing only #include <Security/cssmtype.h> when
building for catalyst by adding a -target arm64-apple-ios13.1-macabi triple,
due to those __OSX_AVAILABLE macros not being set correctly.

If a potential future SDK version were to include cssmtype.h transitively
from a common header such as <Foundation/Foundation.h>, then it would become
close to impossible to build Catalyst binaries with open-source clang.

To fix this for normal catalyst builds, it's only necessary that
__has_builtin() evaluates to true for these two built-ins -- the implementation
of them doesn't matter. But as a courtesy, a correct (at least on the test
cases I tried) implementation is provided. (This should also help people who
try to build zippered code, where having the correct implementation does
matter.)

[thakis]

Another patch to make open-source clang more like Xcode's clang, needed to parse system headers.

https://github.com/nico/hack/blob/main/notes/catalyst.md has some background information on catalyst triples and zippered code.

clang/lib/Lex/PPMacroExpansion.cpp

1713

(I saw this comment, but system headers force our hand.)

[hans]

lgtm

clang/include/clang/Lex/Preprocessor.h

class Preprocessor {
   IdentifierInfo *Ident__MODULE__;                 // __MODULE__
   IdentifierInfo *Ident__has_cpp_attribute;        // __has_cpp_attribute
   IdentifierInfo *Ident__has_c_attribute;          // __has_c_attribute
   IdentifierInfo *Ident__has_declspec;             // __has_declspec_attribute
   IdentifierInfo *Ident__is_target_arch;           // __is_target_arch
   IdentifierInfo *Ident__is_target_vendor;         // __is_target_vendor
   IdentifierInfo *Ident__is_target_os;             // __is_target_os
   IdentifierInfo *Ident__is_target_environment;    // __is_target_environment
+  IdentifierInfo *Ident__is_target_variant_os;
+  IdentifierInfo *Ident__is_target_variant_environment;
   IdentifierInfo *Ident__FLT_EVAL_METHOD__;        // __FLT_EVAL_METHOD
 
   // Weak, only valid (and set) while InMacroArgs is true.
   Token* ArgMacro;
 
   SourceLocation DATELoc, TIMELoc;
 
   // FEM_UnsetOnCommandLine means that an explicit evaluation method was

clang/lib/Lex/PPMacroExpansion.cpp

void Preprocessor::RegisterBuiltinMacros() {
   Ident__has_include_next = RegisterBuiltinMacro(*this, "__has_include_next");
   Ident__has_warning      = RegisterBuiltinMacro(*this, "__has_warning");
   Ident__is_identifier    = RegisterBuiltinMacro(*this, "__is_identifier");
   Ident__is_target_arch   = RegisterBuiltinMacro(*this, "__is_target_arch");
   Ident__is_target_vendor = RegisterBuiltinMacro(*this, "__is_target_vendor");
   Ident__is_target_os     = RegisterBuiltinMacro(*this, "__is_target_os");
   Ident__is_target_environment =
       RegisterBuiltinMacro(*this, "__is_target_environment");
+  Ident__is_target_variant_os =
+      RegisterBuiltinMacro(*this, "__is_target_variant_os");
+  Ident__is_target_variant_environment =
+      RegisterBuiltinMacro(*this, "__is_target_variant_environment");
 
   // Modules.
   Ident__building_module  = RegisterBuiltinMacro(*this, "__building_module");
   if (!getLangOpts().CurrentModule.empty())
     Ident__MODULE__ = RegisterBuiltinMacro(*this, "__MODULE__");
   else
     Ident__MODULE__ = nullptr;
 }

 /// Implements the __is_target_environment builtin macro.
 static bool isTargetEnvironment(const TargetInfo &TI,
                                 const IdentifierInfo *II) {
   std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str();
   llvm::Triple Env(EnvName);
   return TI.getTriple().getEnvironment() == Env.getEnvironment();
 }
 
+/// Implements the __is_target_variant_os builtin macro.
+static bool isTargetVariantOS(const TargetInfo &TI, const IdentifierInfo *II) {
+  if (TI.getTriple().isOSDarwin()) {
+    const llvm::Triple *VariantTriple = TI.getDarwinTargetVariantTriple();
+    if (!VariantTriple)
+      return false;
+
+    std::string OSName =
+        (llvm::Twine("unknown-unknown-") + II->getName().lower()).str();
+    llvm::Triple OS(OSName);
+    if (OS.getOS() == llvm::Triple::Darwin) {
+      // Darwin matches macos, ios, etc.
+      return VariantTriple->isOSDarwin();
+    }
+    return VariantTriple->getOS() == OS.getOS();
+  }
+  return false;
+}
+
+/// Implements the __is_target_variant_environment builtin macro.
+static bool isTargetVariantEnvironment(const TargetInfo &TI,
+                                const IdentifierInfo *II) {
+  if (TI.getTriple().isOSDarwin()) {
+    const llvm::Triple *VariantTriple = TI.getDarwinTargetVariantTriple();
+    if (!VariantTriple)
+      return false;
+    std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str();
+    llvm::Triple Env(EnvName);
+    return VariantTriple->getEnvironment() == Env.getEnvironment();
+  }
+  return false;
+}
+
 /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded
 /// as a builtin macro, handle it and return the next token as 'Tok'.
 void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
   // Figure out which token this is.
   IdentifierInfo *II = Tok.getIdentifierInfo();
   assert(II && "Can't be a macro without id info!");
 
   // If this is an _Pragma or Microsoft __pragma directive, expand it,
#include "clang/Basic/TransformTypeTraits.def"
               .Default(false);
         } else {
           return llvm::StringSwitch<bool>(II->getName())
               // Report builtin templates as being builtins.
               .Case("__make_integer_seq", getLangOpts().CPlusPlus)
               .Case("__type_pack_element", getLangOpts().CPlusPlus)
               // Likewise for some builtin preprocessor macros.
               // FIXME: This is inconsistent; we usually suggest detecting
               // builtin macros via #ifdef. Don't add more cases here.
               .Case("__is_target_arch", true)
               .Case("__is_target_vendor", true)
               .Case("__is_target_os", true)
               .Case("__is_target_environment", true)
+              .Case("__is_target_variant_os", true)
+              .Case("__is_target_variant_environment", true)
               .Default(false);
         }
       });
   } else if (II == Ident__is_identifier) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
       [](Token &Tok, bool &HasLexedNextToken) -> int {
         return Tok.is(tok::identifier);
       });
#include "clang/Basic/TransformTypeTraits.def"
   } else if (II == Ident__is_target_environment) {
     EvaluateFeatureLikeBuiltinMacro(
         OS, Tok, II, *this, false,
         [this](Token &Tok, bool &HasLexedNextToken) -> int {
           IdentifierInfo *II = ExpectFeatureIdentifierInfo(
               Tok, *this, diag::err_feature_check_malformed);
           return II && isTargetEnvironment(getTargetInfo(), II);
         });
+  } else if (II == Ident__is_target_variant_os) {
+    EvaluateFeatureLikeBuiltinMacro(
+        OS, Tok, II, *this, false,
+        [this](Token &Tok, bool &HasLexedNextToken) -> int {
+          IdentifierInfo *II = ExpectFeatureIdentifierInfo(
+              Tok, *this, diag::err_feature_check_malformed);
+          return II && isTargetVariantOS(getTargetInfo(), II);
+        });
+  } else if (II == Ident__is_target_variant_environment) {
+    EvaluateFeatureLikeBuiltinMacro(
+        OS, Tok, II, *this, false,
+        [this](Token &Tok, bool &HasLexedNextToken) -> int {
+          IdentifierInfo *II = ExpectFeatureIdentifierInfo(
+              Tok, *this, diag::err_feature_check_malformed);
+          return II && isTargetVariantEnvironment(getTargetInfo(), II);
+        });
   } else {
     llvm_unreachable("Unknown identifier!");
   }
   CreateString(OS.str(), Tok, Tok.getLocation(), Tok.getLocation());
   Tok.setFlagValue(Token::StartOfLine, IsAtStartOfLine);
   Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace);
 }
 

clang/test/Preprocessor/is_target_unknown.c

 #if !__is_target_os(unknown)
   #error "mismatching OS"
 #endif
 
 // Unknown environment is allowed.
 #if !__is_target_environment(unknown)
   #error "mismatching environment"
 #endif
+
+// Unknown variant OS is not allowed.
+#if __is_target_variant_os(unknown)
+  #error "mismatching OS"
+#endif
+
+// Unknown variant environment is not allowed.
+#if __is_target_variant_environment(unknown)
+  #error "mismatching environment"
+#endif

clang/test/Preprocessor/is_target_variant.c

+// RUN: %clang_cc1 -fsyntax-only -triple arm64-apple-macos -DMAC -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple arm64-apple-ios13.1 -DIOS -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple arm64-apple-ios13.1-macabi -DCATALYST -verify %s
+// RUN: %clang_cc1 -fsyntax-only -triple arm64-apple-macos12 -darwin-target-variant-triple arm64-apple-ios-macabi -DZIPPERED -verify %s
+// expected-no-diagnostics
+
+#if !__has_builtin(__is_target_variant_os) || !__has_builtin(__is_target_variant_environment)
+  #error "has builtin doesn't work"
+#endif
+
+#ifdef ZIPPERED
+
+  // Target variant is a darwin.
+  #if !__is_target_variant_os(darwin)
+    #error "mismatching variant os"
+  #endif
+
+  // Target variant is not macOS...
+  #if __is_target_variant_os(macos)
+    #error "mismatching variant os"
+  #endif
+
+  // ...but iOS.
+  #if !__is_target_variant_os(ios)
+    #error "mismatching variant os"
+  #endif
+
+  // Zippered builds also set the target variant environment to macabi.
+  // At the moment, only zippered builds set __is_target_variant_os(ios),
+  // so checking __is_target_variant_environment() is currently redundant
+  // with checking the former.
+  #if !__is_target_variant_environment(macabi)
+    #error "mismatching variant environment"
+  #endif
+
+#else
+
+  // In non-zippered builds, even for catalyst, no target variant is set.
+  // So these are all false.
+
+  #if __is_target_variant_os(darwin)
+    #error "mismatching variant os"
+  #endif
+
+  #if __is_target_variant_os(macos)
+    #error "mismatching variant os"
+  #endif
+
+  #if __is_target_variant_os(ios)
+    #error "mismatching variant os"
+  #endif
+
+  #if __is_target_variant_environment(macabi)
+    #error "mismatching variant environment"
+  #endif
+
+#endif
+
+// The target environment in zippered builds is _not_ macabi.
+// The target environment is macabi only in catalyst builds.
+#ifdef CATALYST
+  #if !__is_target_environment(macabi)
+    #error "mismatching environment"
+  #endif
+  #if !__is_target_os(ios)
+    #error "mismatching os"
+  #endif
+#else
+  #if __is_target_environment(macabi)
+    #error "mismatching environment"
+  #endif
+#endif