[Modules] Add platform feature to requires clause

[bruno]

Summary

Allows module map writers to add build requirements based on platform/os. Useful when target features and language dialects aren't enough to conditionalize building a module. Among other things, it also makes it more convenient for modules with the same name but different set of submodules to be described in the same module map.

rdar://problem/43909745

[aprantl]

docs/Modules.rst

471

Does this work with platforms+environment combinations, such as the ios simulator on Darwin?

[bruno]

Addressed Adrian's review. Added support to consider the environment and well the combination platform-environment. @aprantl also handled multiple variants of simulator combinations.

[aprantl]

docs/Modules.rst

471

Is iossimulator a thing? The triple is called x86_64-apple-ios-11.2.3-simulator and the SDK calls itself iphonesimulator, so I wonder if this shouldn't be called ios-simulator or iphonesimulator instead.

[aprantl]

lib/Basic/Module.cpp

101

Ah.. it looks like you are fully aware of this :-)

[rsmith]

docs/Modules.rst

476–477

What is the reason to allow these to be combined into a single feature name rather than treating them as two distinct features? (Eg, requires linux, gnueabi rather than requires linux-gnueabi)?

[bruno]

docs/Modules.rst

476–477

No specific reason other than the convenience of writing triple like requirements. But thinking more about it, it might make more sense to have it decoupled and written as a combination to avoid confusion. Will update the patch to reflect that.

[bruno]

Update patch after review.

[rsmith]

lib/Basic/Module.cpp

81

Comment is out of date.

docs/Modules.rst

.. parsed-literal::
   *requires-declaration*:
     ``requires`` *feature-list*
 
   *feature-list*:
     *feature* (',' *feature*)*
 
   *feature*:
     ``!``:sub:`opt` *identifier*
+    ``!``:sub:`opt` *identifier* '-' *identifier*
 
-The requirements clause allows specific modules or submodules to specify that they are only accessible with certain language dialects or on certain platforms. The feature list is a set of identifiers, defined below. If any of the features is not available in a given translation unit, that translation unit shall not import the module. When building a module for use by a compilation, submodules requiring unavailable features are ignored. The optional ``!`` indicates that a feature is incompatible with the module.
+The requirements clause allows specific modules or submodules to specify that they are only accessible with certain language dialects, platforms, environments and target specific features. The feature list is a set of identifiers, defined below. If any of the features is not available in a given translation unit, that translation unit shall not import the module. When building a module for use by a compilation, submodules requiring unavailable features are ignored. The optional ``!`` indicates that a feature is incompatible with the module.
 
 The following features are defined:
 
 altivec
   The target supports AltiVec.
 
 blocks
   The "blocks" language feature is available.
opencl
   OpenCL is available
 
 tls
   Thread local storage is available.
 
 *target feature*
   A specific target feature (e.g., ``sse4``, ``avx``, ``neon``) is available.
 
+*platform/os*
+  A os/platform variant (e.g. ``freebsd``, ``win32``, ``windows``, ``linux``, ``ios``, ``macos``, ``iossimulator``) is available.
+
+*environment*
+  A environment variant (e.g. ``gnu``, ``gnueabi``, ``android``, ``msvc``) is available.
+
+*platform-environment*
+  A platform-environment variant (e.g. ``linux-gnueabi``, ``windows-msvc``) is available.
 
 **Example:** The ``std`` module can be extended to also include C++ and C++11 headers using a *requires-declaration*:
 
 .. parsed-literal::
 
  module std {
     // C standard library...
 

lib/Basic/Module.cpp

 
 Module::~Module() {
   for (submodule_iterator I = submodule_begin(), IEnd = submodule_end();
        I != IEnd; ++I) {
     delete *I;
   }
 }
 
+static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature) {
+  StringRef Platform = Target.getPlatformName();
+  StringRef Env = Target.getTriple().getEnvironmentName();
+
+  // Attempt to match platform/environment in the following order:
+  // 1. Platform
+  // 2, Environment
+  // 3. Platform-Environment
+  if (Platform == Feature || Target.getTriple().getOSName() == Feature ||
+      Env == Feature)
+    return true;
+
+  auto CmpPlatformEnv = [](StringRef LHS, StringRef RHS) {
+    auto Pos = LHS.find("-");
+    if (Pos == StringRef::npos)
+      return false;
+    SmallString<128> NewLHS = LHS.slice(0, Pos);
+    NewLHS += LHS.slice(Pos+1, LHS.size());
+    return NewLHS == RHS;
+  };
+
+  SmallString<128> PlatformEnv = Target.getTriple().getOSAndEnvironmentName();
+  // Darwin has different but equivalent variants for simulators, example:
+  //   1. x86_64-apple-ios-simulator
+  //   2. x86_64-apple-iossimulator
+  // where both are valid examples of the same platform+environment but in the
+  // variant (2), the simulator is hardcoded as part of the platform name. Both
+  // forms above should match "iossimulator" and "ios-simulator" features.
+  if (Target.getTriple().isOSDarwin() && PlatformEnv.endswith("simulator"))
+    return PlatformEnv == Feature || CmpPlatformEnv(Feature, PlatformEnv) ||
+           CmpPlatformEnv(PlatformEnv, Feature);
+
+  return PlatformEnv == Feature;
+}
+
 /// Determine whether a translation unit built using the current
 /// language options has the given feature.
 static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
                        const TargetInfo &Target) {
   bool HasFeature = llvm::StringSwitch<bool>(Feature)
                         .Case("altivec", LangOpts.AltiVec)
                         .Case("blocks", LangOpts.Blocks)
                         .Case("coroutines", LangOpts.CoroutinesTS)
                         .Case("cplusplus", LangOpts.CPlusPlus)
                         .Case("cplusplus11", LangOpts.CPlusPlus11)
                         .Case("cplusplus14", LangOpts.CPlusPlus14)
                         .Case("cplusplus17", LangOpts.CPlusPlus17)
                         .Case("c99", LangOpts.C99)
                         .Case("c11", LangOpts.C11)
                         .Case("c17", LangOpts.C17)
                         .Case("freestanding", LangOpts.Freestanding)
                         .Case("gnuinlineasm", LangOpts.GNUAsm)
                         .Case("objc", LangOpts.ObjC1)
                         .Case("objc_arc", LangOpts.ObjCAutoRefCount)
                         .Case("opencl", LangOpts.OpenCL)
                         .Case("tls", Target.isTLSSupported())
                         .Case("zvector", LangOpts.ZVector)
-                        .Default(Target.hasFeature(Feature));
+                        .Default(Target.hasFeature(Feature) ||
+                                 isPlatformEnvironment(Target, Feature));
   if (!HasFeature)
     HasFeature = std::find(LangOpts.ModuleFeatures.begin(),
                            LangOpts.ModuleFeatures.end(),
                            Feature) != LangOpts.ModuleFeatures.end();
   return HasFeature;
 }
 
 bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,

lib/Lex/ModuleMap.cpp

enum TokenKind {
       ExcludeKeyword,
       ExplicitKeyword,
       ExportKeyword,
       ExportAsKeyword,
       ExternKeyword,
       FrameworkKeyword,
       LinkKeyword,
       ModuleKeyword,
+      Minus,
       Period,
       PrivateKeyword,
       UmbrellaKeyword,
       UseKeyword,
       RequiresKeyword,
       Star,
       StringLiteral,
       IntegerLiteral,
retry:
   case tok::l_brace:
     Tok.Kind = MMToken::LBrace;
     break;
 
   case tok::l_square:
     Tok.Kind = MMToken::LSquare;
     break;
 
+  case tok::minus:
+    Tok.Kind = MMToken::Minus;
+    break;
+
   case tok::period:
     Tok.Kind = MMToken::Period;
     break;
 
   case tok::r_brace:
     Tok.Kind = MMToken::RBrace;
     break;
 

 ///     'requires' feature-list
 ///
 ///   feature-list:
 ///     feature ',' feature-list
 ///     feature
 ///
 ///   feature:
 ///     '!'[opt] identifier
+///     '!'[opt] identifier '-' identifier
 void ModuleMapParser::parseRequiresDecl() {
   assert(Tok.is(MMToken::RequiresKeyword));
 
   // Parse 'requires' keyword.
   consumeToken();
 
   // Parse the feature-list.
   do {
     bool RequiredState = true;
     if (Tok.is(MMToken::Exclaim)) {
       RequiredState = false;
       consumeToken();
     }
 
     if (!Tok.is(MMToken::Identifier)) {
       Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature);
       HadError = true;
       return;
     }
 
-    // Consume the feature name.
+    // Consume the feature or platform name.
     std::string Feature = Tok.getString();
     consumeToken();
 
+    // Consume enviornment after platform name.
+    if (Tok.is(MMToken::Minus)) {
+      consumeToken();
+      if (!Tok.is(MMToken::Identifier)) {
+        Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature);
+        HadError = true;
+        return;
+      }
+      Feature.append("-");
+      Feature.append(Tok.getString());
+      consumeToken();
+    }
+
     bool IsRequiresExcludedHack = false;
     bool ShouldAddRequirement =
         shouldAddRequirement(ActiveModule, Feature, IsRequiresExcludedHack);
 
     if (IsRequiresExcludedHack)
       UsesRequiresExcludedHack.insert(ActiveModule);
 
     if (ShouldAddRequirement) {
do {
     case MMToken::ExcludeKeyword:
     case MMToken::ExportKeyword:
     case MMToken::ExportAsKeyword:
     case MMToken::HeaderKeyword:
     case MMToken::Identifier:
     case MMToken::LBrace:
     case MMToken::LinkKeyword:
     case MMToken::LSquare:
+    case MMToken::Minus:
     case MMToken::Period:
     case MMToken::PrivateKeyword:
     case MMToken::RBrace:
     case MMToken::RSquare:
     case MMToken::RequiresKeyword:
     case MMToken::Star:
     case MMToken::StringLiteral:
     case MMToken::IntegerLiteral:

test/Modules/target-platform-features.m

+// Clear and create directories
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: mkdir %t/cache
+// RUN: mkdir %t/InputsA
+
+// RUN: echo "module RequiresMacOS {"       >> %t/InputsA/module.map
+// RUN: echo "  requires macos"             >> %t/InputsA/module.map
+// RUN: echo "}"                            >> %t/InputsA/module.map
+// RUN: echo "module RequiresNotiOS {"      >> %t/InputsA/module.map
+// RUN: echo "  requires !ios"              >> %t/InputsA/module.map
+// RUN: echo "}"                            >> %t/InputsA/module.map
+// RUN: echo "module RequiresMain {"        >> %t/InputsA/module.map
+// RUN: echo "  module SubRequiresNotiOS {" >> %t/InputsA/module.map
+// RUN: echo "    requires !ios"            >> %t/InputsA/module.map
+// RUN: echo "  }"                          >> %t/InputsA/module.map
+// RUN: echo "}"                            >> %t/InputsA/module.map
+
+// RUN: %clang_cc1 -triple=x86_64-apple-macosx10.6 -DENABLE_DARWIN -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x objective-c -I%t/InputsA -verify %s 
+// expected-no-diagnostics
+
+// RUN: not %clang_cc1 -triple=arm64-apple-ios -DENABLE_DARWIN -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x objective-c -I%t/InputsA %s  2> %t/notios
+// RUN: FileCheck %s -check-prefix=CHECK-IOS < %t/notios
+#ifdef ENABLE_DARWIN
+// CHECK-IOS: module 'RequiresMacOS' requires feature 'macos'
+@import RequiresMacOS;
+// CHECK-IOS: module 'RequiresNotiOS' is incompatible with feature 'ios'
+@import RequiresNotiOS;
+// We should never get errors for submodules that don't match
+// CHECK-IOS-NOT: module 'RequiresMain'
+@import RequiresMain;
+#endif
+
+// RUN: mkdir %t/InputsB
+// RUN: echo "module RequiresiOSSimA {"     >> %t/InputsB/module.map
+// RUN: echo "  requires iossimulator"      >> %t/InputsB/module.map
+// RUN: echo "}"                            >> %t/InputsB/module.map
+// RUN: echo "module RequiresiOSSimB {"     >> %t/InputsB/module.map
+// RUN: echo "  requires ios-simulator"     >> %t/InputsB/module.map
+// RUN: echo "}"                            >> %t/InputsB/module.map
+// RUN: %clang_cc1 -triple=x86_64-apple-iossimulator -DENABLE_IOSSIM -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x objective-c -I%t/InputsB %s  -verify
+// RUN: %clang_cc1 -triple=x86_64-apple-ios-simulator -DENABLE_IOSSIM -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x objective-c -I%t/InputsB %s  -verify
+
+#ifdef ENABLE_IOSSIM
+@import RequiresiOSSimA;
+@import RequiresiOSSimB;
+#endif
+
+// RUN: mkdir %t/InputsC
+// RUN: echo "module RequiresLinuxEABIA {"  >> %t/InputsC/module.map
+// RUN: echo "  requires linux-gnueabi"     >> %t/InputsC/module.map
+// RUN: echo "}"                            >> %t/InputsC/module.map
+// RUN: echo "module RequiresLinuxEABIB {"  >> %t/InputsC/module.map
+// RUN: echo "  requires gnueabi"           >> %t/InputsC/module.map
+// RUN: echo "}"                            >> %t/InputsC/module.map
+// RUN: echo "module RequiresLinuxEABIC {"  >> %t/InputsC/module.map
+// RUN: echo "  requires linux"             >> %t/InputsC/module.map
+// RUN: echo "}"                            >> %t/InputsC/module.map
+// RUN: %clang_cc1 -triple=armv8r-none-linux-gnueabi -DENABLE_LINUXEABI -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x objective-c -I%t/InputsC %s -verify
+
+#ifdef ENABLE_LINUXEABI
+@import RequiresLinuxEABIA;
+@import RequiresLinuxEABIB;
+@import RequiresLinuxEABIC;
+#endif
+
+// RUN: mkdir %t/InputsD
+// RUN: echo "module RequiresWinMSVCA {"  >> %t/InputsD/module.map
+// RUN: echo "  requires windows"         >> %t/InputsD/module.map
+// RUN: echo "}"                          >> %t/InputsD/module.map
+// RUN: echo "module RequiresWinMSVCB {"  >> %t/InputsD/module.map
+// RUN: echo "  requires windows-msvc"    >> %t/InputsD/module.map
+// RUN: echo "}"                          >> %t/InputsD/module.map
+// RUN: echo "module RequiresWinMSVCC {"  >> %t/InputsD/module.map
+// RUN: echo "  requires msvc"            >> %t/InputsD/module.map
+// RUN: echo "}"                          >> %t/InputsD/module.map
+// RUN: %clang_cc1 -triple=thumbv7-unknown-windows-msvc -DENABLE_WINMSVC -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x objective-c -I%t/InputsD %s  -verify
+
+#ifdef ENABLE_WINMSVC
+@import RequiresWinMSVCA;
+@import RequiresWinMSVCB;
+@import RequiresWinMSVCC;
+#endif