Move functionality for handling module maps as inputs from the -emit-module

action to the general FrontendAction infrastructure.

This permits applying -E, -ast-dump, -fsyntax-only, and so on to a module map
compilation. (The -E form is not currently especially useful yet as there's no
good way to take the output and use it to actually build a module.)

In order to support this, -cc1 now accepts -x <lang>-module-map in all cases
where it accepts -x <lang> for a language we can parse (not ir/ast). And for
uniformity, we also accept -x <lang>-header for all such languages (we used
to reject for cuda and renderscript), and -x <lang>-cpp-output for all such
languages (we used to reject for c, cl, and renderscript).

(None of these new alternatives are accepted by the driver yet, so no
user-visible changes.)


git-svn-id: http://llvm.org/svn/llvm-project/cfe/trunk@301610 91177308-0d34-0410-b5e6-96231b3b80d8

Author: rsmith

include/clang/Frontend/FrontendActions.h

@@ -99,8 +99,6 @@ class GenerateModuleAction : public ASTFrontendAction {
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) = 0;
 
 protected:
-  bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override;
-
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 
@@ -112,20 +110,11 @@ class GenerateModuleAction : public ASTFrontendAction {
 };
 
 class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
-  clang::Module *Module = nullptr;
-  const FileEntry *ModuleMapForUniquing = nullptr;
-  bool IsSystem = false;
-
 private:
   bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override;
 
   std::unique_ptr<raw_pwrite_stream>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
-
-public:
-  GenerateModuleFromModuleMapAction() {}
-  GenerateModuleFromModuleMapAction(const FileEntry *ModuleMap, bool IsSystem)
-      : ModuleMapForUniquing(ModuleMap), IsSystem(IsSystem) {}
 };
 
 class GenerateModuleInterfaceAction : public GenerateModuleAction {

include/clang/Frontend/FrontendOptions.h

@@ -23,6 +23,7 @@ class MemoryBuffer;
 }
 
 namespace clang {
+class FileEntry;
 
 namespace frontend {
   enum ActionKind {
@@ -100,9 +101,8 @@ class InputKind {
     Precompiled
   };
 
-  constexpr InputKind(Language L = Unknown, bool PP = false)
-      : Lang(L), Fmt(Source), Preprocessed(PP) {}
-  constexpr InputKind(Language L, Format F, bool PP = false)
+  constexpr InputKind(Language L = Unknown, Format F = Source,
+                      bool PP = false)
       : Lang(L), Fmt(F), Preprocessed(PP) {}
 
   Language getLanguage() const { return static_cast<Language>(Lang); }
@@ -118,6 +118,9 @@ class InputKind {
   InputKind getPreprocessed() const {
     return InputKind(getLanguage(), getFormat(), true);
   }
+  InputKind withFormat(Format F) const {
+    return InputKind(getLanguage(), F, isPreprocessed());
+  }
 };
 
 /// \brief An input file for the front end.
@@ -256,6 +259,10 @@ class FrontendOptions {
   /// The input files and their types.
   std::vector<FrontendInputFile> Inputs;
 
+  /// When the input is a module map, the original module map file from which
+  /// that map was inferred, if any (for umbrella modules).
+  std::string OriginalModuleMap;
+
   /// The output file, if any.
   std::string OutputFile;
 

lib/Frontend/CompilerInstance.cpp

@@ -1080,6 +1080,8 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
   FrontendOpts.DisableFree = false;
   FrontendOpts.GenerateGlobalModuleIndex = false;
   FrontendOpts.BuildingImplicitModule = true;
+  FrontendOpts.OriginalModuleMap =
+      ModMap.getModuleMapFileForUniquing(Module)->getName();
   // Force implicitly-built modules to hash the content of the module file.
   HSOpts.ModulesHashContent = true;
   FrontendOpts.Inputs.clear();
@@ -1129,11 +1131,12 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
   if (const FileEntry *ModuleMapFile =
           ModMap.getContainingModuleMapFile(Module)) {
     // Use the module map where this module resides.
-    FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK);
+    FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK,
+                                     +Module->IsSystem);
   } else {
     SmallString<128> FakeModuleMapFile(Module->Directory->getName());
     llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
-    FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK);
+    FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK, +Module->IsSystem);
 
     llvm::raw_string_ostream OS(InferredModuleMapContent);
     Module->print(OS);
@@ -1146,11 +1149,6 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
     SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
   }
 
-  // Construct a module-generating action. Passing through the module map is
-  // safe because the FileManager is shared between the compiler instances.
-  GenerateModuleFromModuleMapAction CreateModuleAction(
-      ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
-
   ImportingInstance.getDiagnostics().Report(ImportLoc,
                                             diag::remark_module_build)
     << Module->Name << ModuleFileName;
@@ -1159,8 +1157,12 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
   // thread so that we get a stack large enough.
   const unsigned ThreadStackSize = 8 << 20;
   llvm::CrashRecoveryContext CRC;
-  CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
-                        ThreadStackSize);
+  CRC.RunSafelyOnThread(
+      [&]() {
+        GenerateModuleFromModuleMapAction Action;
+        Instance.ExecuteAction(Action);
+      },
+      ThreadStackSize);
 
   ImportingInstance.getDiagnostics().Report(ImportLoc,
                                             diag::remark_module_build_done)

lib/Frontend/CompilerInvocation.cpp

@@ -1350,30 +1350,51 @@ static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
   InputKind DashX(InputKind::Unknown);
   if (const Arg *A = Args.getLastArg(OPT_x)) {
     StringRef XValue = A->getValue();
+
+    // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'.
+    // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
+    bool Preprocessed = XValue.consume_back("-cpp-output");
+    bool ModuleMap = XValue.consume_back("-module-map");
+    IsHeaderFile =
+        !Preprocessed && !ModuleMap && XValue.consume_back("-header");
+
+    // Principal languages.
     DashX = llvm::StringSwitch<InputKind>(XValue)
-      .Cases("c", "c-header", "cpp-output", InputKind::C)
-      .Cases("cl", "cl-header", InputKind::OpenCL)
-      .Cases("cuda", "cuda-cpp-output", InputKind::CUDA)
-      .Cases("c++", "c++-header", "c++-cpp-output", InputKind::CXX)
-      .Cases("objective-c", "objective-c-header",
-             "objective-c-cpp-output", "objc-cpp-output",
-             InputKind::ObjC)
-      .Cases("objective-c++", "objective-c++-header",
-             "objective-c++-cpp-output", "objc++-cpp-output",
-             InputKind::ObjCXX)
-      .Case("renderscript", InputKind::RenderScript)
-      .Case("assembler-with-cpp", InputKind::Asm)
-      .Cases("ast", "pcm",
-             InputKind(InputKind::Unknown, InputKind::Precompiled))
-      .Case("ir", InputKind::LLVM_IR)
-      .Default(InputKind::Unknown);
+                .Case("c", InputKind::C)
+                .Case("cl", InputKind::OpenCL)
+                .Case("cuda", InputKind::CUDA)
+                .Case("c++", InputKind::CXX)
+                .Case("objective-c", InputKind::ObjC)
+                .Case("objective-c++", InputKind::ObjCXX)
+                .Case("renderscript", InputKind::RenderScript)
+                .Default(InputKind::Unknown);
+
+    // "objc[++]-cpp-output" is an acceptable synonym for
+    // "objective-c[++]-cpp-output".
+    if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap)
+      DashX = llvm::StringSwitch<InputKind>(XValue)
+                  .Case("objc", InputKind::ObjC)
+                  .Case("objc++", InputKind::ObjCXX)
+                  .Default(InputKind::Unknown);
+
+    // Some special cases cannot be combined with suffixes.
+    if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile)
+      DashX = llvm::StringSwitch<InputKind>(XValue)
+                  .Case("cpp-output", InputKind(InputKind::C).getPreprocessed())
+                  .Case("assembler-with-cpp", InputKind::Asm)
+                  .Cases("ast", "pcm",
+                         InputKind(InputKind::Unknown, InputKind::Precompiled))
+                  .Case("ir", InputKind::LLVM_IR)
+                  .Default(InputKind::Unknown);
+
     if (DashX.isUnknown())
       Diags.Report(diag::err_drv_invalid_value)
         << A->getAsString(Args) << A->getValue();
 
-    if (XValue.endswith("cpp-output"))
+    if (Preprocessed)
       DashX = DashX.getPreprocessed();
-    IsHeaderFile = XValue.endswith("-header");
+    if (ModuleMap)
+      DashX = DashX.withFormat(InputKind::ModuleMap);
   }
 
   // '-' is the default input if none is given.
@@ -1393,6 +1414,12 @@ static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
       if (i == 0)
         DashX = IK;
     }
+
+    // The -emit-module action implicitly takes a module map.
+    if (Opts.ProgramAction == frontend::GenerateModule &&
+        IK.getFormat() == InputKind::Source)
+      IK = IK.withFormat(InputKind::ModuleMap);
+
     Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
   }