[clang][modules] Avoid storing command-line macro definitions into implicitly built PCM files

[jansvoboda11]

Summary

With implicit modules, it's impossible to load a PCM file that was built using different command-line macro definitions. This is guaranteed by the fact that they contribute to the context hash. This means that we don't need to store those macros into PCM files for validation purposes. This patch avoids serializing them in those circumstances, since there's no other use for command-line macro definitions (besides "-module-file-info").

For a typical Apple project, this speeds up the dependency scan by 5.6% and shrinks the cache with scanning PCMs by 26%.

[jansvoboda11]

Format

[benlangmuir]

clang/test/Modules/module_file_info.m

44–45

CHECK-NOT: Predefined macros ?

clang/include/clang/Serialization/ASTReader.h

public:
   ///
   /// \param SuggestedPredefines Can be filled in with the set of predefines
   /// that are suggested by the preprocessor options. Typically only used when
   /// loading a precompiled header.
   ///
   /// \returns true to indicate the preprocessor options are invalid, or false
   /// otherwise.
   virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
-                                       bool Complain,
+                                       bool ReadMacros, bool Complain,
                                        std::string &SuggestedPredefines) {
     return false;
   }
 
   /// Receives __COUNTER__ value.
   virtual void ReadCounter(const serialization::ModuleFile &M,
                            unsigned Value) {}
 
bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
                              bool Complain) override;
   bool ReadFileSystemOptions(const FileSystemOptions &FSOpts,
                              bool Complain) override;
 
   bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                StringRef SpecificModuleCachePath,
                                bool Complain) override;
   bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
-                               bool Complain,
+                               bool ReadMacros, bool Complain,
                                std::string &SuggestedPredefines) override;
 
   void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override;
   bool needsInputFileVisitation() override;
   bool needsSystemInputFileVisitation() override;
   void visitModuleFile(StringRef Filename,
                        serialization::ModuleKind Kind) override;
   bool visitInputFile(StringRef Filename, bool isSystem,
PCHValidator(Preprocessor &PP, ASTReader &Reader)
       : PP(PP), Reader(Reader) {}
 
   bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
                            bool AllowCompatibleDifferences) override;
   bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
                          bool AllowCompatibleDifferences) override;
   bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
                              bool Complain) override;
-  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
+  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
+                               bool ReadMacros, bool Complain,
                                std::string &SuggestedPredefines) override;
   bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                StringRef SpecificModuleCachePath,
                                bool Complain) override;
   void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override;
 
 private:
   void Error(const char *Msg);
 };
 
 /// ASTReaderListenter implementation to set SuggestedPredefines of
 /// ASTReader which is required to use a pch file. This is the replacement
 /// of PCHValidator or SimplePCHValidator when using a pch file without
 /// validating it.
 class SimpleASTReaderListener : public ASTReaderListener {
   Preprocessor &PP;
 
 public:
   SimpleASTReaderListener(Preprocessor &PP) : PP(PP) {}
 
-  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
+  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
+                               bool ReadMacros, bool Complain,
                                std::string &SuggestedPredefines) override;
 };
 
 namespace serialization {
 
 class ReadMethodPoolVisitor;
 
 namespace reader {

clang/include/clang/Serialization/ASTWriter.h

private:
   std::string BaseDirectory;
 
   /// Indicates whether timestamps should be written to the produced
   /// module file. This is the case for files implicitly written to the
   /// module cache, where we need the timestamps to determine if the module
   /// file is up to date, but not otherwise.
   bool IncludeTimestamps;
 
+  /// Indicates whether the AST file being written is an implicit module.
+  /// If that's the case, we may be able to skip writing some information that
+  /// are guaranteed to be the same in the importer by the context hash.
+  bool BuildingImplicitModule = false;
+
   /// Indicates when the AST writing is actively performing
   /// serialization, rather than just queueing updates.
   bool WritingAST = false;
 
   /// Indicates that we are done serializing the collection of decls
   /// and types to emit.
   bool DoneWritingDeclsAndTypes = false;
 
ASTFileSignature WriteASTCore(Sema &SemaRef, StringRef isysroot,
                                 Module *WritingModule);
 
 public:
   /// Create a new precompiled header writer that outputs to
   /// the given bitstream.
   ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
             InMemoryModuleCache &ModuleCache,
             ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
-            bool IncludeTimestamps = true);
+            bool IncludeTimestamps = true, bool BuildingImplicitModule = false);
   ~ASTWriter() override;
 
   ASTContext &getASTContext() const {
     assert(Context && "requested AST context when not writing AST");
     return *Context;
   }
 
   const LangOptions &getLangOpts() const;
protected:
   SmallVectorImpl<char> &getPCH() const { return Buffer->Data; }
 
 public:
   PCHGenerator(const Preprocessor &PP, InMemoryModuleCache &ModuleCache,
                StringRef OutputFile, StringRef isysroot,
                std::shared_ptr<PCHBuffer> Buffer,
                ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
                bool AllowASTWithErrors = false, bool IncludeTimestamps = true,
+               bool BuildingImplicitModule = false,
                bool ShouldCacheASTInMemory = false);
   ~PCHGenerator() override;
 
   void InitializeSema(Sema &S) override { SemaPtr = &S; }
   void HandleTranslationUnit(ASTContext &Ctx) override;
   ASTMutationListener *GetASTMutationListener() override;
   ASTDeserializationListener *GetASTDeserializationListener() override;
   bool hasEmittedPCH() const { return Buffer->IsComplete; }
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SERIALIZATION_ASTWRITER_H

clang/lib/Frontend/ASTUnit.cpp

PP.getFileManager().setVirtualFileSystem(createVFSFromOverlayFiles(
         HSOpts.VFSOverlayFiles, PP.getDiagnostics(),
         PP.getFileManager().getVirtualFileSystemPtr()));
 
     InitializedHeaderSearchPaths = true;
 
     return false;
   }
 
-  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain,
+  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
+                               bool ReadMacros, bool Complain,
                                std::string &SuggestedPredefines) override {
     this->PPOpts = PPOpts;
     return false;
   }
 
   bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
                          bool AllowCompatibleDifferences) override {
     // If we've already initialized the target, don't do it again.

clang/lib/Frontend/FrontendActions.cpp

GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
 
   const auto &FrontendOpts = CI.getFrontendOpts();
   auto Buffer = std::make_shared<PCHBuffer>();
   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
   Consumers.push_back(std::make_unique<PCHGenerator>(
       CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
       FrontendOpts.ModuleFileExtensions,
       CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
-      FrontendOpts.IncludeTimestamps, +CI.getLangOpts().CacheGeneratedPCH));
+      FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
+      +CI.getLangOpts().CacheGeneratedPCH));
   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
       CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
 
   return std::make_unique<MultiplexConsumer>(std::move(Consumers));
 }
 
 bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
                                                     std::string &Sysroot) {
GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
   Consumers.push_back(std::make_unique<PCHGenerator>(
       CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
       CI.getFrontendOpts().ModuleFileExtensions,
       /*AllowASTWithErrors=*/
       +CI.getFrontendOpts().AllowPCMWithCompilerErrors,
       /*IncludeTimestamps=*/
       +CI.getFrontendOpts().BuildingImplicitModule &&
           +CI.getFrontendOpts().IncludeTimestamps,
+      /*BuildingImplicitModule=*/+CI.getFrontendOpts().BuildingImplicitModule,
       /*ShouldCacheASTInMemory=*/
       +CI.getFrontendOpts().BuildingImplicitModule));
   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
       CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
   return std::make_unique<MultiplexConsumer>(std::move(Consumers));
 }
 
 bool GenerateModuleAction::shouldEraseOutputFiles() {
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
       DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
                    "Use standard C++ include directories [-nostdinc++]");
       DUMP_BOOLEAN(HSOpts.UseLibcxx,
                    "Use libc++ (rather than libstdc++) [-stdlib=]");
       return false;
     }
 
     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
-                                 bool Complain,
+                                 bool ReadMacros, bool Complain,
                                  std::string &SuggestedPredefines) override {
       Out.indent(2) << "Preprocessor options:\n";
       DUMP_BOOLEAN(PPOpts.UsePredefines,
                    "Uses compiler/target-specific predefines [-undef]");
       DUMP_BOOLEAN(PPOpts.DetailedRecord,
                    "Uses detailed preprocessing record (for indexing)");
 
-      if (!PPOpts.Macros.empty()) {
+      if (ReadMacros) {
         Out.indent(4) << "Predefined macros:\n";
       }
 
       for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
              I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
            I != IEnd; ++I) {
         Out.indent(6);
         if (I->second)

clang/lib/Serialization/ASTReader.cpp

bool ChainedASTReaderListener::ReadHeaderSearchOptions(
     bool Complain) {
   return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
                                         Complain) ||
          Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
                                          Complain);
 }
 
 bool ChainedASTReaderListener::ReadPreprocessorOptions(
-    const PreprocessorOptions &PPOpts, bool Complain,
+    const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain,
     std::string &SuggestedPredefines) {
-  return First->ReadPreprocessorOptions(PPOpts, Complain,
+  return First->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
                                         SuggestedPredefines) ||
-         Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
+         Second->ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
+                                         SuggestedPredefines);
 }
 
 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
                                            unsigned Value) {
   First->ReadCounter(M, Value);
   Second->ReadCounter(M, Value);
 }
 

 /// \param Validation If set to OptionValidateNone, ignore differences in
 ///        preprocessor options. If set to OptionValidateContradictions,
 ///        require that options passed both in the AST file and on the command
 ///        line (-D or -U) match, but tolerate options missing in one or the
 ///        other. If set to OptionValidateContradictions, require that there
 ///        are no differences in the options between the two.
 static bool checkPreprocessorOptions(
     const PreprocessorOptions &PPOpts,
-    const PreprocessorOptions &ExistingPPOpts, DiagnosticsEngine *Diags,
-    FileManager &FileMgr, std::string &SuggestedPredefines,
-    const LangOptions &LangOpts,
+    const PreprocessorOptions &ExistingPPOpts, bool ReadMacros,
+    DiagnosticsEngine *Diags, FileManager &FileMgr,
+    std::string &SuggestedPredefines, const LangOptions &LangOpts,
     OptionValidation Validation = OptionValidateContradictions) {
+  if (ReadMacros) {
     // Check macro definitions.
     MacroDefinitionsMap ASTFileMacros;
     collectMacroDefinitions(PPOpts, ASTFileMacros);
     MacroDefinitionsMap ExistingMacros;
     SmallVector<StringRef, 4> ExistingMacroNames;
     collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
 
     // Use a line marker to enter the <command line> file, as the defines and
     // undefines here will have come from the command line.
     SuggestedPredefines += "# 1 \"<command line>\" 1\n";
 
     for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
       // Dig out the macro definition in the existing preprocessor options.
       StringRef MacroName = ExistingMacroNames[I];
       std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
 
       // Check whether we know anything about this macro name or not.
       llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
           ASTFileMacros.find(MacroName);
       if (Validation == OptionValidateNone || Known == ASTFileMacros.end()) {
         if (Validation == OptionValidateStrictMatches) {
           // If strict matches are requested, don't tolerate any extra defines on
           // the command line that are missing in the AST file.
           if (Diags) {
             Diags->Report(diag::err_pch_macro_def_undef) << MacroName << true;
           }
           return true;
         }
         // FIXME: Check whether this identifier was referenced anywhere in the
         // AST file. If so, we should reject the AST file. Unfortunately, this
         // information isn't in the control block. What shall we do about it?
 
         if (Existing.second) {
           SuggestedPredefines += "#undef ";
           SuggestedPredefines += MacroName.str();
           SuggestedPredefines += '\n';
         } else {
           SuggestedPredefines += "#define ";
           SuggestedPredefines += MacroName.str();
           SuggestedPredefines += ' ';
           SuggestedPredefines += Existing.first.str();
           SuggestedPredefines += '\n';
         }
         continue;
       }
 
       // If the macro was defined in one but undef'd in the other, we have a
       // conflict.
       if (Existing.second != Known->second.second) {
         if (Diags) {
           Diags->Report(diag::err_pch_macro_def_undef)
               << MacroName << Known->second.second;
         }
         return true;
       }
 
       // If the macro was #undef'd in both, or if the macro bodies are identical,
       // it's fine.
       if (Existing.second || Existing.first == Known->second.first) {
         ASTFileMacros.erase(Known);
         continue;
       }
 
       // The macro bodies differ; complain.
       if (Diags) {
         Diags->Report(diag::err_pch_macro_def_conflict)
             << MacroName << Known->second.first << Existing.first;
       }
       return true;
     }
 
     // Leave the <command line> file and return to <built-in>.
     SuggestedPredefines += "# 1 \"<built-in>\" 2\n";
 
     if (Validation == OptionValidateStrictMatches) {
       // If strict matches are requested, don't tolerate any extra defines in
       // the AST file that are missing on the command line.
       for (const auto &MacroName : ASTFileMacros.keys()) {
         if (Diags) {
           Diags->Report(diag::err_pch_macro_def_undef) << MacroName << false;
         }
         return true;
       }
     }
+  }
 
   // Check whether we're using predefines.
   if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines &&
       Validation != OptionValidateNone) {
     if (Diags) {
       Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
     }
     return true;
for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
     SuggestedPredefines += File;
     SuggestedPredefines += "\"\n##\n";
   }
 
   return false;
 }
 
 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
-                                           bool Complain,
+                                           bool ReadMacros, bool Complain,
                                            std::string &SuggestedPredefines) {
   const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
 
-  return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
+  return checkPreprocessorOptions(PPOpts, ExistingPPOpts, ReadMacros,
                                   Complain? &Reader.Diags : nullptr,
                                   PP.getFileManager(),
                                   SuggestedPredefines,
                                   PP.getLangOpts());
 }
 
 bool SimpleASTReaderListener::ReadPreprocessorOptions(
-                                  const PreprocessorOptions &PPOpts,
-                                  bool Complain,
-                                  std::string &SuggestedPredefines) {
-  return checkPreprocessorOptions(PPOpts, PP.getPreprocessorOpts(), nullptr,
-                                  PP.getFileManager(), SuggestedPredefines,
-                                  PP.getLangOpts(), OptionValidateNone);
+    const PreprocessorOptions &PPOpts, bool ReadMacros, bool Complain,
+  return checkPreprocessorOptions(PPOpts, PP.getPreprocessorOpts(), ReadMacros,
+                                  nullptr, PP.getFileManager(),
+                                  SuggestedPredefines, PP.getLangOpts(),
+                                  OptionValidateNone);
 }
 
 /// Check the header search options deserialized from the control block
 /// against the header search options in an existing preprocessor.
 ///
 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                      StringRef SpecificModuleCachePath,
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
                                  StringRef SpecificModuleCachePath,
                                  bool Complain) override {
       return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
                                       ExistingModuleCachePath, nullptr,
                                       ExistingLangOpts, ExistingPPOpts);
     }
 
     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
-                                 bool Complain,
+                                 bool ReadMacros, bool Complain,
                                  std::string &SuggestedPredefines) override {
       return checkPreprocessorOptions(
-          PPOpts, ExistingPPOpts, /*Diags=*/nullptr, FileMgr,
+          PPOpts, ExistingPPOpts, ReadMacros, /*Diags=*/nullptr, FileMgr,
           SuggestedPredefines, ExistingLangOpts,
           StrictOptionMatches ? OptionValidateStrictMatches
                               : OptionValidateContradictions);
     }
   };
 
 } // namespace
 
bool ASTReader::ParseHeaderSearchPaths(const RecordData &Record, bool Complain,
   for (unsigned N = Record[Idx++]; N; --N) {
     std::string VFSOverlayFile = ReadString(Record, Idx);
     HSOpts.VFSOverlayFiles.emplace_back(std::move(VFSOverlayFile));
   }
 
   return Listener.ReadHeaderSearchPaths(HSOpts, Complain);
 }
 
-bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
-                                         bool Complain,
+bool ASTReader::ParsePreprocessorOptions(const RecordData &Record, bool Complain,
                                          ASTReaderListener &Listener,
                                          std::string &SuggestedPredefines) {
   PreprocessorOptions PPOpts;
   unsigned Idx = 0;
 
   // Macro definitions/undefs
+  bool ReadMacros = Record[Idx++];
+  if (ReadMacros) {
     for (unsigned N = Record[Idx++]; N; --N) {
       std::string Macro = ReadString(Record, Idx);
       bool IsUndef = Record[Idx++];
       PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
     }
+  }
 
   // Includes
   for (unsigned N = Record[Idx++]; N; --N) {
     PPOpts.Includes.push_back(ReadString(Record, Idx));
   }
 
   // Macro Includes
   for (unsigned N = Record[Idx++]; N; --N) {
     PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
   }
 
   PPOpts.UsePredefines = Record[Idx++];
   PPOpts.DetailedRecord = Record[Idx++];
   PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
   PPOpts.ObjCXXARCStandardLibrary =
     static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
   SuggestedPredefines.clear();
-  return Listener.ReadPreprocessorOptions(PPOpts, Complain,
+  return Listener.ReadPreprocessorOptions(PPOpts, ReadMacros, Complain,
                                           SuggestedPredefines);
 }
 
 std::pair<ModuleFile *, unsigned>
 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
   GlobalPreprocessedEntityMapType::iterator
   I = GlobalPreprocessedEntityMap.find(GlobalIndex);
   assert(I != GlobalPreprocessedEntityMap.end() &&

clang/lib/Serialization/ASTWriter.cpp

#include "clang/Basic/Sanitizers.def"
   // Write out the specific module cache path that contains the module files.
   AddString(PP.getHeaderSearchInfo().getModuleCachePath(), Record);
   Stream.EmitRecord(HEADER_SEARCH_OPTIONS, Record);
 
   // Preprocessor options.
   Record.clear();
   const PreprocessorOptions &PPOpts = PP.getPreprocessorOpts();
 
+  // If we're building an implicit module with a context hash, the importer is
+  // guaranteed to have the same macros defined on the command line. Skip
+  // writing them.
+  bool SkipMacros = BuildingImplicitModule && !HSOpts.DisableModuleHash;
+  bool WriteMacros = !SkipMacros;
+  Record.push_back(WriteMacros);
+  if (WriteMacros) {
     // Macro definitions.
     Record.push_back(PPOpts.Macros.size());
     for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
       AddString(PPOpts.Macros[I].first, Record);
       Record.push_back(PPOpts.Macros[I].second);
     }
+  }
 
   // Includes
   Record.push_back(PPOpts.Includes.size());
   for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I)
     AddString(PPOpts.Includes[I], Record);
 
   // Macro includes
   Record.push_back(PPOpts.MacroIncludes.size());
if (ID < FirstSelectorID)
     return;
   SelectorOffsets[ID - FirstSelectorID] = Offset;
 }
 
 ASTWriter::ASTWriter(llvm::BitstreamWriter &Stream,
                      SmallVectorImpl<char> &Buffer,
                      InMemoryModuleCache &ModuleCache,
                      ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
-                     bool IncludeTimestamps)
+                     bool IncludeTimestamps, bool BuildingImplicitModule)
     : Stream(Stream), Buffer(Buffer), ModuleCache(ModuleCache),
-      IncludeTimestamps(IncludeTimestamps) {
+      IncludeTimestamps(IncludeTimestamps),
+      BuildingImplicitModule(BuildingImplicitModule) {
   for (const auto &Ext : Extensions) {
     if (auto Writer = Ext->createExtensionWriter(*this))
       ModuleFileExtensionWriters.push_back(std::move(Writer));
   }
 }
 
 ASTWriter::~ASTWriter() = default;
 

clang/lib/Serialization/GeneratePCH.cpp

 
 using namespace clang;
 
 PCHGenerator::PCHGenerator(
     const Preprocessor &PP, InMemoryModuleCache &ModuleCache,
     StringRef OutputFile, StringRef isysroot, std::shared_ptr<PCHBuffer> Buffer,
     ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
     bool AllowASTWithErrors, bool IncludeTimestamps,
-    bool ShouldCacheASTInMemory)
+    bool BuildingImplicitModule, bool ShouldCacheASTInMemory)
     : PP(PP), OutputFile(OutputFile), isysroot(isysroot.str()),
       SemaPtr(nullptr), Buffer(std::move(Buffer)), Stream(this->Buffer->Data),
       Writer(Stream, this->Buffer->Data, ModuleCache, Extensions,
-             IncludeTimestamps),
+             IncludeTimestamps, BuildingImplicitModule),
       AllowASTWithErrors(AllowASTWithErrors),
       ShouldCacheASTInMemory(ShouldCacheASTInMemory) {
   this->Buffer->IsComplete = false;
 }
 
 PCHGenerator::~PCHGenerator() {
 }
 

clang/test/Modules/module_file_info.m

 // CHECK:   Resource dir [ -resource-dir=]: '{{.*}}clang{{.*}}'
 // CHECK:   Use builtin include directories [-nobuiltininc]: Yes
 // CHECK:   Use standard system include directories [-nostdinc]: No
 // CHECK:   Use standard C++ include directories [-nostdinc++]: Yes
 // CHECK:   Use libc++ (rather than libstdc++) [-stdlib=]:
 
 // CHECK: Preprocessor options:
 // CHECK:   Uses compiler/target-specific predefines [-undef]: Yes
 // CHECK:   Uses detailed preprocessing record (for indexing): No
-// CHECK:   Predefined macros:
-// CHECK:     -DBLARG
-// CHECK:     -DWIBBLE=WOBBLE
 // CHECK: Input file: {{.*}}module.map
 // CHECK-NEXT: Input file: {{.*}}module_private.map
 // CHECK-NEXT: Input file: {{.*}}DependsOnModule.h
 // CHECK-NEXT: Input file: {{.*}}module.map
 // CHECK-NEXT: Input file: {{.*}}other.h
 // CHECK-NEXT: Input file: {{.*}}not_cxx.h
 // CHECK-NEXT: Input file: {{.*}}not_coroutines.h
 // CHECK-NEXT: Input file: {{.*}}SubFramework.h
 // CHECK-NEXT: Input file: {{.*}}Other.h
 // CHECK-NEXT: Input file: {{.*}}DependsOnModulePrivate.h
 
 // CHECK: Diagnostic options:
 // CHECK:   IgnoreWarnings: Yes
 // CHECK:   Diagnostic flags:
 // CHECK:     -Wunused