Postpone module macro update until all headers are parsed.

[sepavloff]

Summary

This change fixes performance degradation reported in PR24667. The reason
of the problem is leaving module after each header, even if the next header
is of the same module. With this fix module state record counts the number of
headers parsed within particular module. Macro update starts when this number
reaches the number of headers specified in the module descriptor.

Using script from PR24667 the performance measurement gives numbers (compile
time vs number of headers):

128 0.0362679958344
256 0.0517950057983
512 0.0877501964569
1024 0.171896934509
2048 0.393149137497
4096 1.02584791183
8192 3.1531829834

While without the fix compiler demonstrates quadratic compile time:

128 0.0541491508484
256 0.121176958084
512 0.330996990204
1024 1.10708594322
2048 4.06581497192
4096 16.0358121395
8192 66.6967120171

include/clang/Lex/Preprocessor.h

struct BuildingSubmoduleInfo {
     SourceLocation ImportLoc;
     /// The previous SubmoduleState.
     SubmoduleState *OuterSubmoduleState;
   };
   SmallVector<BuildingSubmoduleInfo, 8> BuildingSubmoduleStack;
 
   /// \brief Information about a submodule's preprocessor state.
   struct SubmoduleState {
+    SubmoduleState() : NumCompiledHeaders(0) {}
     /// The macros for the submodule.
     MacroMap Macros;
     /// The set of modules that are visible within the submodule.
     VisibleModuleSet VisibleModules;
+    /// Number of module headers compiled so far.
+    unsigned NumCompiledHeaders;
     // FIXME: CounterValue?
     // FIXME: PragmaPushMacroInfo?
   };
   std::map<Module*, SubmoduleState> Submodules;
 
   /// The preprocessor state for preprocessing outside of any submodule.
   SubmoduleState NullSubmoduleState;
 

lib/Lex/PPLexerChange.cpp

if (!IncludeMacroStack.empty()) {
     }
 
     FileID ExitedFID;
     if (Callbacks && !isEndOfMacro && CurPPLexer)
       ExitedFID = CurPPLexer->getFileID();
 
     bool LeavingSubmodule = CurSubmodule && CurLexer;
     if (LeavingSubmodule) {
+      ++CurSubmoduleState->NumCompiledHeaders;
+
       // Notify the parser that we've left the module.
       const char *EndPos = getCurLexerEndPos();
       Result.startToken();
       CurLexer->BufferPtr = EndPos;
       CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_module_end);
       Result.setAnnotationEndLoc(Result.getLocation());
       Result.setAnnotationValue(CurSubmodule);
 
if (getLangOpts().ModulesLocalVisibility) {
       if (PredefMacroIt == PredefMacros.end())
         OldMD = nullptr;
       else
         OldMD = PredefMacroIt->second.getLatest();
     }
 
     // This module may have exported a new macro. If so, create a ModuleMacro
     // representing that fact.
+    // We do this only if when the last module header is compiled, to avoid
+    // repeating updates of macro set.
+    if (CurSubmoduleState->NumCompiledHeaders >=
+        LeavingMod->Headers[Module::HK_Normal].size()) {
       bool ExplicitlyPublic = false;
       for (auto *MD = Macro.second.getLatest(); MD != OldMD;
            MD = MD->getPrevious()) {
         assert(MD && "broken macro directive chain");
 
-      // Stop on macros defined in other submodules we #included along the way.
-      // There's no point doing this if we're tracking local submodule
+        // Stop on macros defined in other submodules we #included along the
+        // way. There's no point doing this if we're tracking local submodule
         // visibility, since there can be no such directives in our list.
         if (!getLangOpts().ModulesLocalVisibility) {
           Module *Mod = getModuleContainingLocation(MD->getLocation());
           if (Mod != LeavingMod)
             break;
         }
 
         if (auto *VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {
           // The latest visibility directive for a name in a submodule affects
           // all the directives that come before it.
           if (VisMD->isPublic())
             ExplicitlyPublic = true;
           else if (!ExplicitlyPublic)
             // Private with no following public directive: not exported.
             break;
         } else {
           MacroInfo *Def = nullptr;
           if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
             Def = DefMD->getInfo();
 
           // FIXME: Issue a warning if multiple headers for the same submodule
           // define a macro, rather than silently ignoring all but the first.
           bool IsNew;
           // Don't bother creating a module macro if it would represent a #undef
           // that doesn't override anything.
           if (Def || !Macro.second.getOverriddenMacros().empty())
             addModuleMacro(LeavingMod, II, Def,
                            Macro.second.getOverriddenMacros(), IsNew);
           break;
         }
       }
     }
+  }
 
   // FIXME: Before we leave this submodule, we should parse all the other
   // headers within it. Otherwise, we're left with an inconsistent state
   // where we've made the module visible but don't yet have its complete
   // contents.
 
   // Put back the outer module's state, if we're tracking it.
   if (getLangOpts().ModulesLocalVisibility)
     CurSubmoduleState = Info.OuterSubmoduleState;
 
   BuildingSubmoduleStack.pop_back();
 
   // A nested #include makes the included submodule visible.
   makeModuleVisible(LeavingMod, ImportLoc);
 }