CbC/CbC_llvm: tools/clang/lib/Lex/PPLexerChange.cpp comparison

comparison tools/clang/lib/Lex/PPLexerChange.cpp @ 126:c4cc77a799c9

fix

author	mir3636
date	Mon, 04 Dec 2017 21:20:52 +0900
parents	36195a0db682
children	7c836c76d71d

comparison

equal deleted inserted replaced

-:56c5119fbcd2
+:c4cc77a799c9
 return IncludeMacroStack.empty();
 // If there are any stacked lexers, we're in a #include.
 assert(IsFileLexer(IncludeMacroStack[0]) &&
 "Top level include stack isn't our primary lexer?");
-for (unsigned i = 1, e = IncludeMacroStack.size(); i != e; ++i)
+return std::none_of(
-if (IsFileLexer(IncludeMacroStack[i]))
+IncludeMacroStack.begin() + 1, IncludeMacroStack.end(),
-return false;
+[&](const IncludeStackInfo &ISI) -> bool { return IsFileLexer(ISI); });
-return true;
 }
 /// getCurrentLexer - Return the current file lexer being lexed from.  Note
 /// that this ignores any potentially active macro expansions and _Pragma
 /// expansions going on at the time.
 PreprocessorLexer *Preprocessor::getCurrentFileLexer() const {
 if (IsFileLexer())
 return CurPPLexer;
 // Look for a stacked lexer.
-for (unsigned i = IncludeMacroStack.size(); i != 0; --i) {
+for (const IncludeStackInfo &ISI : llvm::reverse(IncludeMacroStack)) {
-const IncludeStackInfo& ISI = IncludeMacroStack[i-1];
 if (IsFileLexer(ISI))
 return ISI.ThePPLexer;
 }
 return nullptr;
 }
 PushIncludeMacroStack();
 CurLexer.reset(TheLexer);
 CurPPLexer = TheLexer;
 CurDirLookup = CurDir;
-CurSubmodule = nullptr;
+CurLexerSubmodule = nullptr;
 if (CurLexerKind != CLK_LexAfterModuleImport)
 CurLexerKind = CLK_Lexer;
 // Notify the client, if desired, that we are in a new source file.
 if (Callbacks && !CurLexer->Is_PragmaLexer) {
 PushIncludeMacroStack();
 CurDirLookup = CurDir;
 CurPTHLexer.reset(PL);
 CurPPLexer = CurPTHLexer.get();
-CurSubmodule = nullptr;
+CurLexerSubmodule = nullptr;
 if (CurLexerKind != CLK_LexAfterModuleImport)
 CurLexerKind = CLK_PTHLexer;
 // Notify the client, if desired, that we are in a new source file.
 if (Callbacks) {
 }
 return EndPos;
 }
+static void collectAllSubModulesWithUmbrellaHeader(
+const Module &Mod, SmallVectorImpl<const Module *> &SubMods) {
+if (Mod.getUmbrellaHeader())
+SubMods.push_back(&Mod);
+for (auto *M : Mod.submodules())
+collectAllSubModulesWithUmbrellaHeader(*M, SubMods);
+}
+void Preprocessor::diagnoseMissingHeaderInUmbrellaDir(const Module &Mod) {
+assert(Mod.getUmbrellaHeader() && "Module must use umbrella header");
+SourceLocation StartLoc =
+SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
+if (getDiagnostics().isIgnored(diag::warn_uncovered_module_header, StartLoc))
+return;
+ModuleMap &ModMap = getHeaderSearchInfo().getModuleMap();
+const DirectoryEntry *Dir = Mod.getUmbrellaDir().Entry;
+vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
+std::error_code EC;
+for (vfs::recursive_directory_iterator Entry(FS, Dir->getName(), EC), End;
+Entry != End && !EC; Entry.increment(EC)) {
+using llvm::StringSwitch;
+// Check whether this entry has an extension typically associated with
+// headers.
+if (!StringSwitch<bool>(llvm::sys::path::extension(Entry->getName()))
+.Cases(".h", ".H", ".hh", ".hpp", true)
+.Default(false))
+continue;
+if (const FileEntry *Header = getFileManager().getFile(Entry->getName()))
+if (!getSourceManager().hasFileInfo(Header)) {
+if (!ModMap.isHeaderInUnavailableModule(Header)) {
+// Find the relative path that would access this header.
+SmallString<128> RelativePath;
+computeRelativePath(FileMgr, Dir, Header, RelativePath);
+Diag(StartLoc, diag::warn_uncovered_module_header)
+<< Mod.getFullModuleName() << RelativePath;
+}
+}
+}
+}
 /// HandleEndOfFile - This callback is invoked when the lexer hits the end of
 /// the current file.  This either returns the EOF token or pops a level off
 /// the include stack and keeps going.
 bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {
 assert(!CurTokenLexer &&
 "Ending a file when currently in a macro!");
+// If we have an unclosed module region from a pragma at the end of a
+// module, complain and close it now.
+// FIXME: This is not correct if we are building a module from PTH.
+const bool LeavingSubmodule = CurLexer && CurLexerSubmodule;
+if ((LeavingSubmodule || IncludeMacroStack.empty()) &&
+!BuildingSubmoduleStack.empty() &&
+BuildingSubmoduleStack.back().IsPragma) {
+Diag(BuildingSubmoduleStack.back().ImportLoc,
+diag::err_pp_module_begin_without_module_end);
+Module *M = LeaveSubmodule(/*ForPragma*/true);
+Result.startToken();
+const char *EndPos = getCurLexerEndPos();
+CurLexer->BufferPtr = EndPos;
+CurLexer->FormTokenWithChars(Result, EndPos, tok::annot_module_end);
+Result.setAnnotationEndLoc(Result.getLocation());
+Result.setAnnotationValue(M);
+return true;
+}
 // See if this file had a controlling macro.
 if (CurPPLexer) {  // Not ending a macro, ignore it.
 if (const IdentifierInfo *ControllingMacro =
 CurPPLexer->MIOpt.GetControllingMacroAtEndOfFile()) {
 // Okay, this has a controlling macro, remember in HeaderFileInfo.
 if (const FileEntry *FE = CurPPLexer->getFileEntry()) {
 HeaderInfo.SetFileControllingMacro(FE, ControllingMacro);
 if (MacroInfo *MI =
-getMacroInfo(const_cast<IdentifierInfo*>(ControllingMacro))) {
+getMacroInfo(const_cast<IdentifierInfo*>(ControllingMacro)))
-MI->UsedForHeaderGuard = true;
+MI->setUsedForHeaderGuard(true);
-}
 if (const IdentifierInfo *DefinedMacro =
 CurPPLexer->MIOpt.GetDefinedMacro()) {
 if (!isMacroDefined(ControllingMacro) &&
 DefinedMacro != ControllingMacro &&
 HeaderInfo.FirstTimeLexingFile(FE)) {
 SourceMgr.local_sloc_entry_size() -
 CurPPLexer->getInitialNumSLocEntries() + 1/*#include'd file*/;
 SourceMgr.setNumCreatedFIDsForFileID(CurPPLexer->getFileID(), NumFIDs);
 }
+bool ExitedFromPredefinesFile = false;
 FileID ExitedFID;
-if (Callbacks && !isEndOfMacro && CurPPLexer)
+if (!isEndOfMacro && CurPPLexer) {
 ExitedFID = CurPPLexer->getFileID();
-bool LeavingSubmodule = CurSubmodule && CurLexer;
+assert(PredefinesFileID.isValid() &&
+"HandleEndOfFile is called before PredefinesFileId is set");
+ExitedFromPredefinesFile = (PredefinesFileID == ExitedFID);
+}
 if (LeavingSubmodule) {
+// We're done with this submodule.
+Module *M = LeaveSubmodule(/*ForPragma*/false);
 // 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);
+Result.setAnnotationValue(M);
-// We're done with this submodule.
-LeaveSubmodule();
 }
 // We're done with the #included file.
 RemoveTopOfLexerStack();
 // Propagate info about start-of-line/leading white-space/etc.
 PropagateLineStartLeadingSpaceInfo(Result);
 // Notify the client, if desired, that we are in a new source file.
 if (Callbacks && !isEndOfMacro && CurPPLexer) {
 SrcMgr::CharacteristicKind FileType =
 SourceMgr.getFileCharacteristic(CurPPLexer->getSourceLocation());
 Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
 PPCallbacks::ExitFile, FileType, ExitedFID);
 }
 #ifndef noCbC
 if (SavedTokenFlag && IncludeMacroStack.size() == SavedDepth){
 Result = SavedToken;
 SavedTokenFlag = false;
 if (CurLexer->ParsingPreprocessorDirective) {
 CurLexer->IsAtStartOfLine = true;
 CurLexer->IsAtPhysicalStartOfLine = true;
 }
 return true;
 }
 #endif
+// Restore conditional stack from the preamble right after exiting from the
+// predefines file.
+if (ExitedFromPredefinesFile)
+replayPreambleConditionalStack();
 // Client should lex another token unless we generated an EOM.
 return LeavingSubmodule;
 }
 // If this is the end of the main file, form an EOF token.
 I!=E; ++I)
 Diag(*I, diag::pp_macro_not_used);
 }
 // If we are building a module that has an umbrella header, make sure that
-// each of the headers within the directory covered by the umbrella header
+// each of the headers within the directory, including all submodules, is
-// was actually included by the umbrella header.
+// covered by the umbrella header was actually included by the umbrella
+// header.
 if (Module *Mod = getCurrentModule()) {
-if (Mod->getUmbrellaHeader()) {
+llvm::SmallVector<const Module *, 4> AllMods;
-SourceLocation StartLoc
+collectAllSubModulesWithUmbrellaHeader(*Mod, AllMods);
-= SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
+for (auto *M : AllMods)
+diagnoseMissingHeaderInUmbrellaDir(*M);
-if (!getDiagnostics().isIgnored(diag::warn_uncovered_module_header,
-StartLoc)) {
-ModuleMap &ModMap = getHeaderSearchInfo().getModuleMap();
-const DirectoryEntry *Dir = Mod->getUmbrellaDir().Entry;
-vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
-std::error_code EC;
-for (vfs::recursive_directory_iterator Entry(FS, Dir->getName(), EC), End;
-Entry != End && !EC; Entry.increment(EC)) {
-using llvm::StringSwitch;
-// Check whether this entry has an extension typically associated with
-// headers.
-if (!StringSwitch<bool>(llvm::sys::path::extension(Entry->getName()))
-.Cases(".h", ".H", ".hh", ".hpp", true)
-.Default(false))
-continue;
-if (const FileEntry *Header =
-getFileManager().getFile(Entry->getName()))
-if (!getSourceManager().hasFileInfo(Header)) {
-if (!ModMap.isHeaderInUnavailableModule(Header)) {
-// Find the relative path that would access this header.
-SmallString<128> RelativePath;
-computeRelativePath(FileMgr, Dir, Header, RelativePath);
-Diag(StartLoc, diag::warn_uncovered_module_header)
-<< Mod->getFullModuleName() << RelativePath;
-}
-}
-}
-}
-}
 }
 return true;
 }
 // We handle this by scanning for the closest real lexer, switching it to
 // raw mode and preprocessor mode.  This will cause it to return \n as an
 // explicit EOD token.
 PreprocessorLexer *FoundLexer = nullptr;
 bool LexerWasInPPMode = false;
-for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) {
+for (const IncludeStackInfo &ISI : llvm::reverse(IncludeMacroStack)) {
-IncludeStackInfo &ISI = *(IncludeMacroStack.end()-i-1);
 if (ISI.ThePPLexer == nullptr) continue;  // Scan for a real lexer.
 // Once we find a real lexer, mark it as raw mode (disabling macro
 // expansions) and preprocessor mode (return EOD).  We know that the lexer
 // was *not* in raw mode before, because the macro that the comment came
 // active (an active lexer would return EOD at EOF if there was no \n in
 // preprocessor directive mode), so just return EOF as our token.
 assert(!FoundLexer && "Lexer should return EOD before EOF in PP mode");
 }
-void Preprocessor::EnterSubmodule(Module *M, SourceLocation ImportLoc) {
+void Preprocessor::EnterSubmodule(Module *M, SourceLocation ImportLoc,
+bool ForPragma) {
 if (!getLangOpts().ModulesLocalVisibility) {
 // Just track that we entered this submodule.
 BuildingSubmoduleStack.push_back(
-BuildingSubmoduleInfo(M, ImportLoc, CurSubmoduleState));
+BuildingSubmoduleInfo(M, ImportLoc, ForPragma, CurSubmoduleState,
+PendingModuleMacroNames.size()));
 return;
 }
 // Resolve as much of the module definition as we can now, before we enter
 // one of its headers.
 }
 }
 // Track that we entered this module.
 BuildingSubmoduleStack.push_back(
-BuildingSubmoduleInfo(M, ImportLoc, CurSubmoduleState));
+BuildingSubmoduleInfo(M, ImportLoc, ForPragma, CurSubmoduleState,
+PendingModuleMacroNames.size()));
 // Switch to this submodule as the current submodule.
 CurSubmoduleState = &State;
 // This module is visible to itself.
 if (FirstTime)
 makeModuleVisible(M, ImportLoc);
 }
-void Preprocessor::LeaveSubmodule() {
+bool Preprocessor::needModuleMacros() const {
+// If we're not within a submodule, we never need to create ModuleMacros.
+if (BuildingSubmoduleStack.empty())
+return false;
+// If we are tracking module macro visibility even for textually-included
+// headers, we need ModuleMacros.
+if (getLangOpts().ModulesLocalVisibility)
+return true;
+// Otherwise, we only need module macros if we're actually compiling a module
+// interface.
+return getLangOpts().isCompilingModule();
+}
+Module *Preprocessor::LeaveSubmodule(bool ForPragma) {
+if (BuildingSubmoduleStack.empty() ||
+BuildingSubmoduleStack.back().IsPragma != ForPragma) {
+assert(ForPragma && "non-pragma module enter/leave mismatch");
+return nullptr;
+}
 auto &Info = BuildingSubmoduleStack.back();
 Module *LeavingMod = Info.M;
 SourceLocation ImportLoc = Info.ImportLoc;
+if (!needModuleMacros() ||
+(!getLangOpts().ModulesLocalVisibility &&
+LeavingMod->getTopLevelModuleName() != getLangOpts().CurrentModule)) {
+// If we don't need module macros, or this is not a module for which we
+// are tracking macro visibility, don't build any, and preserve the list
+// of pending names for the surrounding submodule.
+BuildingSubmoduleStack.pop_back();
+makeModuleVisible(LeavingMod, ImportLoc);
+return LeavingMod;
+}
 // Create ModuleMacros for any macros defined in this submodule.
-for (auto &Macro : CurSubmoduleState->Macros) {
+llvm::SmallPtrSet<const IdentifierInfo*, 8> VisitedMacros;
-auto *II = const_cast<IdentifierInfo*>(Macro.first);
+for (unsigned I = Info.OuterPendingModuleMacroNames;
+I != PendingModuleMacroNames.size(); ++I) {
+auto *II = const_cast<IdentifierInfo*>(PendingModuleMacroNames[I]);
+if (!VisitedMacros.insert(II).second)
+continue;
+auto MacroIt = CurSubmoduleState->Macros.find(II);
+if (MacroIt == CurSubmoduleState->Macros.end())
+continue;
+auto &Macro = MacroIt->second;
 // Find the starting point for the MacroDirective chain in this submodule.
 MacroDirective *OldMD = nullptr;
-if (getLangOpts().ModulesLocalVisibility) {
+auto *OldState = Info.OuterSubmoduleState;
+if (getLangOpts().ModulesLocalVisibility)
+OldState = &NullSubmoduleState;
+if (OldState && OldState != CurSubmoduleState) {
 // FIXME: It'd be better to start at the state from when we most recently
 // entered this submodule, but it doesn't really matter.
-auto &PredefMacros = NullSubmoduleState.Macros;
+auto &OldMacros = OldState->Macros;
-auto PredefMacroIt = PredefMacros.find(Macro.first);
+auto OldMacroIt = OldMacros.find(II);
-if (PredefMacroIt == PredefMacros.end())
+if (OldMacroIt == OldMacros.end())
 OldMD = nullptr;
 else
-OldMD = PredefMacroIt->second.getLatest();
+OldMD = OldMacroIt->second.getLatest();
 }
 // This module may have exported a new macro. If so, create a ModuleMacro
 // representing that fact.
 bool ExplicitlyPublic = false;
-for (auto *MD = Macro.second.getLatest(); MD != OldMD;
+for (auto *MD = Macro.getLatest(); MD != OldMD; MD = MD->getPrevious()) {
-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
-// 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())
 // 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())
+if (Def || !Macro.getOverriddenMacros().empty())
 addModuleMacro(LeavingMod, II, Def,
-Macro.second.getOverriddenMacros(), IsNew);
+Macro.getOverriddenMacros(), IsNew);
+if (!getLangOpts().ModulesLocalVisibility) {
+// This macro is exposed to the rest of this compilation as a
+// ModuleMacro; we don't need to track its MacroDirective any more.
+Macro.setLatest(nullptr);
+Macro.setOverriddenMacros(*this, {});
+}
 break;
 }
 }
 }
+PendingModuleMacroNames.resize(Info.OuterPendingModuleMacroNames);
 // 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.
 BuildingSubmoduleStack.pop_back();
 // A nested #include makes the included submodule visible.
 makeModuleVisible(LeavingMod, ImportLoc);
-}
+return LeavingMod;
+}

Mercurial > hg > CbC > CbC_llvm

comparison tools/clang/lib/Lex/PPLexerChange.cpp @ 126:c4cc77a799c9