jansvoboda11 updated this revision to Diff 473043.
jansvoboda11 added a comment.
Handle macros
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D137259/new/
https://reviews.llvm.org/D137259
Files:
clang/include/clang/Frontend/CompilerInstance.h
clang/include/clang/Lex/Token.h
clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
clang/lib/Frontend/CompilerInstance.cpp
clang/lib/Serialization/GeneratePCH.cpp
clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
clang/test/ClangScanDeps/modules-basic.c
Index: clang/test/ClangScanDeps/modules-basic.c
===================================================================
--- /dev/null
+++ clang/test/ClangScanDeps/modules-basic.c
@@ -0,0 +1,76 @@
+// RUN: rm -rf %t
+// RUN: split-file %s %t
+
+//--- include/module.modulemap
+module m { header "m.h"}
+//--- include/m.h
+#define FOO
+//--- include/t.h
+
+//--- tu.c
+#include "m.h"
+#ifdef FOO
+#include "t.h"
+#endif
+
+//--- cdb.json.template
+[{
+ "file": "DIR/tu.c",
+ "directory": "DIR",
+ "command": "clang -fsyntax-only DIR/tu.c -fmodules -fmodules-cache-path=DIR/cache -fimplicit-module-maps -I DIR/include"
+}]
+
+// RUN: sed "s|DIR|%/t|g" %t/cdb.json.template > %t/cdb.json
+
+// RUN: clang-scan-deps -compilation-database %t/cdb.json -format experimental-full > %t/result.json
+// RUN: cat %t/result.json | sed 's:\\\\\?:/:g' | FileCheck %s -DPREFIX=%/t
+
+// CHECK: {
+// CHECK-NEXT: "modules": [
+// CHECK-NEXT: {
+// CHECK-NEXT: "clang-module-deps": [],
+// CHECK-NEXT: "clang-modulemap-file": "[[PREFIX]]/include/module.modulemap",
+// CHECK-NEXT: "command-line": [
+// CHECK-NEXT: "-cc1",
+// CHECK: "-o",
+// CHECK-NEXT: "[[PREFIX]]/cache/{{.*}}/m-{{.*}}.pcm",
+// CHECK: "-emit-module",
+// CHECK: "[[PREFIX]]/include/module.modulemap",
+// CHECK: "-fmodules",
+// CHECK: "-fmodule-name=m",
+// CHECK: ],
+// CHECK-NEXT: "context-hash": "[[M_HASH:.*]]",
+// CHECK-NEXT: "file-deps": [
+// CHECK-NEXT: "[[PREFIX]]/include/m.h",
+// CHECK-NEXT: "[[PREFIX]]/include/module.modulemap"
+// CHECK-NEXT: ],
+// CHECK-NEXT: "name": "m"
+// CHECK-NEXT: }
+// CHECK-NEXT: ],
+// CHECK-NEXT: "translation-units": [
+// CHECK-NEXT: {
+// CHECK-NEXT: "commands": [
+// CHECK-NEXT: {
+// CHECK-NEXT: "clang-context-hash": "{{.*}}",
+// CHECK-NEXT: "clang-module-deps": [
+// CHECK-NEXT: {
+// CHECK-NEXT: "context-hash": "[[M_HASH]]",
+// CHECK-NEXT: "module-name": "m"
+// CHECK-NEXT: }
+// CHECK-NEXT: ],
+// CHECK-NEXT: "command-line": [
+// CHECK-NEXT: "-cc1",
+// CHECK: "-fmodule-map-file=[[PREFIX]]/include/module.modulemap",
+// CHECK: "-fmodule-file=m=[[PREFIX]]/cache/{{.*}}/m-{{.*}}.pcm",
+// CHECK: ],
+// CHECK-NEXT: "executable": "clang",
+// CHECK-NEXT: "file-deps": [
+// CHECK-NEXT: "[[PREFIX]]/tu.c",
+// CHECK-NEXT: "[[PREFIX]]/include/t.h"
+// CHECK-NEXT: ],
+// CHECK-NEXT: "input-file": "[[PREFIX]]/tu.c"
+// CHECK-NEXT: }
+// CHECK-NEXT: ]
+// CHECK-NEXT: }
+// CHECK-NEXT: ]
+// CHECK-NEXT: }
Index: clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
===================================================================
--- clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
+++ clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp
@@ -375,15 +375,8 @@
if (!MDC.isPrebuiltModule(M))
DirectModularDeps.insert(M);
- for (const Module *M : DirectModularDeps) {
- // A top-level module might not be actually imported as a module when
- // -fmodule-name is used to compile a translation unit that imports this
- // module. In that case it can be skipped. The appropriate header
- // dependencies will still be reported as expected.
- if (!M->getASTFile())
- continue;
+ for (const Module *M : DirectModularDeps)
handleTopLevelModule(M);
- }
MDC.Consumer.handleDependencyOutputOpts(*MDC.Opts);
@@ -410,7 +403,6 @@
MD.ID.ModuleName = M->getFullModuleName();
MD.ImportedByMainFile = DirectModularDeps.contains(M);
- MD.ImplicitModulePCMPath = std::string(M->getASTFile()->getName());
MD.IsSystem = M->IsSystem;
ModuleMap &ModMapInfo =
@@ -424,40 +416,30 @@
MD.ClangModuleMapFile = std::string(Path);
}
- serialization::ModuleFile *MF =
- MDC.ScanInstance.getASTReader()->getModuleManager().lookup(
- M->getASTFile());
- MDC.ScanInstance.getASTReader()->visitInputFiles(
- *MF, true, true, [&](const serialization::InputFile &IF, bool isSystem) {
- // __inferred_module.map is the result of the way in which an implicit
- // module build handles inferred modules. It adds an overlay VFS with
- // this file in the proper directory and relies on the rest of Clang to
- // handle it like normal. With explicitly built modules we don't need
- // to play VFS tricks, so replace it with the correct module map.
- if (IF.getFile()->getName().endswith("__inferred_module.map")) {
- MDC.addFileDep(MD, ModuleMap->getName());
- return;
- }
- MDC.addFileDep(MD, IF.getFile()->getName());
- });
-
- llvm::DenseSet<const Module *> SeenDeps;
- addAllSubmodulePrebuiltDeps(M, MD, SeenDeps);
- addAllSubmoduleDeps(M, MD, SeenDeps);
- addAllAffectingClangModules(M, MD, SeenDeps);
-
- MDC.ScanInstance.getASTReader()->visitTopLevelModuleMaps(
- *MF, [&](const FileEntry *FE) {
- if (FE->getName().endswith("__inferred_module.map"))
- return;
- MD.ModuleMapFileDeps.emplace_back(FE->getName());
- });
+ for (const auto &E : MDC.ScanInstance.SortedFiles[M->getFullModuleName()]) {
+ if (E.FE->getName().endswith("__inferred_module.map")) {
+ MDC.addFileDep(MD, ModuleMap->getName());
+ continue;
+ }
+ MDC.addFileDep(MD, E.FE->getName());
+ }
+ if (M->NoUndeclaredIncludes) {
+ for (const auto &E : MDC.ScanInstance.SortedFiles[M->getFullModuleName()]) {
+ if (E.FE->getName().endswith("__inferred_module.map"))
+ continue;
+ // The top-level modulemap of this module will be the input file. We
+ // don't need to specify it as a module map.
+ if (E.FE == ModuleMap)
+ continue;
+ MD.ModuleMapFileDeps.push_back(E.FE->getName().str());
+ }
+ }
CompilerInvocation CI = MDC.makeInvocationForModuleBuildWithoutOutputs(
MD, [&](CompilerInvocation &BuildInvocation) {
- if (MDC.OptimizeArgs)
- optimizeHeaderSearchOpts(BuildInvocation.getHeaderSearchOpts(),
- *MDC.ScanInstance.getASTReader(), *MF);
+// if (MDC.OptimizeArgs)
+// optimizeHeaderSearchOpts(BuildInvocation.getHeaderSearchOpts(),
+// *MDC.ScanInstance.getASTReader(), *MF);
});
MDC.associateWithContextHash(CI, MD);
Index: clang/lib/Serialization/GeneratePCH.cpp
===================================================================
--- clang/lib/Serialization/GeneratePCH.cpp
+++ clang/lib/Serialization/GeneratePCH.cpp
@@ -39,6 +39,9 @@
}
void PCHGenerator::HandleTranslationUnit(ASTContext &Ctx) {
+ // Do not attempt to write the AST file.
+ return;
+
// Don't create a PCH if there were fatal failures during module loading.
if (PP.getModuleLoader().HadFatalFailure)
return;
Index: clang/lib/Frontend/CompilerInstance.cpp
===================================================================
--- clang/lib/Frontend/CompilerInstance.cpp
+++ clang/lib/Frontend/CompilerInstance.cpp
@@ -1129,6 +1129,344 @@
return LangOpts.CPlusPlus ? Language::CXX : Language::C;
}
+class Translator {
+ CompilerInstance &A;
+ Preprocessor &APP;
+ SourceManager &ASM;
+ FileManager &AFM;
+ HeaderSearch &AHS;
+
+ const CompilerInstance &B;
+ const Preprocessor &BPP;
+ const SourceManager &BSM;
+ const FileManager &BFM;
+ HeaderSearch &BHS;
+
+ llvm::StringSet<> TranslatedModules;
+
+public:
+ Translator(CompilerInstance &A, const CompilerInstance &B)
+ : A(A), APP(A.getPreprocessor()), ASM(A.getSourceManager()),
+ AFM(A.getFileManager()), AHS(A.getPreprocessor().getHeaderSearchInfo()),
+ B(B), BPP(B.getPreprocessor()), BSM(B.getSourceManager()),
+ BFM(B.getFileManager()),
+ BHS(B.getPreprocessor().getHeaderSearchInfo()) {}
+
+ template <class T> Optional<T> translate(const Optional<T> &BO) {
+ if (!BO)
+ return None;
+ return translate(*BO);
+ }
+
+ template <class T> const T *translate(const T *BP) {
+ if (!BP)
+ return nullptr;
+ return &translate(*BP);
+ }
+
+ template <class T> T *translate(T *BP) {
+ if (!BP)
+ return nullptr;
+ return &translate(*BP);
+ }
+
+ template <class T, class U>
+ llvm::PointerUnion<T, U> translate(llvm::PointerUnion<T, U> BPU) {
+ if (!BPU)
+ return nullptr;
+ if (BPU.template is<T>())
+ return translate(BPU.template get<T>());
+ return translate(BPU.template get<U>());
+ }
+
+ template <class T, unsigned N>
+ SmallVector<T, N> translate(const SmallVector<T, N> &BV) {
+ SmallVector<T, N> AV;
+ AV.reserve(BV.size());
+ for (const T &Entry : BV)
+ AV.push_back(translate(Entry));
+ return AV;
+ }
+
+ template <class T, unsigned N>
+ llvm::SmallSetVector<T, N> translate(const llvm::SmallSetVector<T, N>& BSSV) {
+ llvm::SmallSetVector<T, N> ASSV;
+ for (const auto &Entry : BSSV)
+ ASSV.insert(translate(Entry));
+ return ASSV;
+ }
+
+ const FileEntry &translate(const FileEntry &BFE) {
+ return **AFM.getFile(BFE.getName());
+ }
+
+ FileEntryRef translate(FileEntryRef BFE) {
+ return *AFM.getOptionalFileRef(BFE.getName());
+ }
+
+ const DirectoryEntry &translate(const DirectoryEntry &BDE) {
+ return **AFM.getDirectory(BDE.getName());
+ }
+
+ SourceLocation translate(SourceLocation BLoc) {
+ if (BLoc.isInvalid())
+ return {};
+
+ auto BOffset = BSM.getFileOffset(BLoc);
+ auto AOffset = BOffset;
+
+ auto BFileID = BSM.getFileID(BLoc);
+ auto AFileID = [&]() {
+ if (BFileID == BPP.getPredefinesFileID())
+ return APP.getPredefinesFileID();
+
+ auto BFileCharacteristic = BSM.getFileCharacteristic(BLoc);
+ auto AFileCharacteristic = BFileCharacteristic;
+
+ auto *BFileEntry = BSM.getFileEntryForID(BFileID);
+ auto *AFileEntry = translate(BFileEntry);
+ return ASM.getOrCreateFileID(AFileEntry, AFileCharacteristic);
+ }();
+
+ return ASM.getComposedLoc(AFileID, AOffset);
+ }
+
+ Module::Header translate(const Module::Header &BHeader) {
+ return Module::Header{BHeader.NameAsWritten,
+ BHeader.PathRelativeToRootModuleDirectory,
+ translate(BHeader.Entry)};
+ }
+
+ std::vector<Module *> translate(Module::submodule_iterator Begin,
+ Module::submodule_iterator End) {
+ std::vector<Module *> ASubModules;
+ for (auto It = Begin; It != End; ++It)
+ ASubModules.push_back(translate(*It));
+ return ASubModules;
+ }
+
+ Module::UnresolvedHeaderDirective
+ translate(const Module::UnresolvedHeaderDirective &BD) {
+ return {BD.Kind, //
+ translate(BD.FileNameLoc),
+ BD.FileName,
+ BD.IsUmbrella,
+ BD.HasBuiltinHeader,
+ BD.Size,
+ BD.ModTime};
+ }
+
+ Module::ExportDecl translate(const Module::ExportDecl &BED) {
+ return {translate(BED.getPointer()), BED.getInt()};
+ }
+
+ ModuleId translate(const ModuleId &BId) {
+ ModuleId Res;
+ for (const auto &Element : BId)
+ Res.push_back({Element.first, translate(Element.second)});
+ return Res;
+ }
+
+ Module::UnresolvedExportDecl
+ translate(const Module::UnresolvedExportDecl &BUED) {
+ return {translate(BUED.ExportLoc), translate(BUED.Id), BUED.Wildcard};
+ }
+
+ Module::LinkLibrary translate(const Module::LinkLibrary &X) {
+ return X;
+ }
+
+ Module::UnresolvedConflict translate(const Module::UnresolvedConflict &X) {
+ return {translate(X.Id), X.Message};
+ }
+
+ Module::Conflict translate(const Module::Conflict &X) {
+ return {translate(X.Other), X.Message};
+ }
+
+ const Module &translate(const Module &BMod) {
+ return translate(const_cast<Module &>(BMod));
+ }
+
+ Module &translate(Module &BMod) {
+ auto &AModMap = AHS.getModuleMap();
+
+ auto [AMod, New] = AModMap.findOrCreateModule(
+ BMod.Name, translate(BMod.Parent),
+ BMod.IsFramework, BMod.IsExplicit);
+
+ if (!TranslatedModules.insert(BMod.Name).second)
+ return *AMod;
+
+ AMod->Kind = BMod.Kind;
+ AMod->Directory = translate(BMod.Directory);
+ AMod->PresumedModuleMapFile = BMod.PresumedModuleMapFile;
+ AMod->DefinitionLoc = translate(BMod.DefinitionLoc);
+ AMod->Umbrella = translate(BMod.Umbrella);
+ AMod->UmbrellaAsWritten = BMod.UmbrellaAsWritten;
+ AMod->UmbrellaRelativeToRootModuleDirectory =
+ BMod.UmbrellaRelativeToRootModuleDirectory;
+ AMod->ExportAsModule = BMod.ExportAsModule;
+
+ for (Module *BSubMod : BMod.submodules())
+ translate(BSubMod);
+
+ for (const FileEntry *BTopHeader : BMod.getTopHeaders(B.getFileManager()))
+ AMod->addTopHeader(translate(BTopHeader));
+
+ // TODO: Propagate VisibilityID to other data structures.
+
+ for (auto Kind : {Module::HK_Normal, Module::HK_Textual, Module::HK_Private,
+ Module::HK_PrivateTextual, Module::HK_Excluded}) {
+ for (const auto &BH : BMod.Headers[Kind]) {
+ const auto &AH = translate(BH);
+ AModMap.addHeader(AMod, AH, ModuleMap::headerKindToRole(Kind),
+ BHS.getFileInfo(BH.Entry).isModuleHeader);
+ }
+ }
+
+ AMod->UnresolvedHeaders = translate(BMod.UnresolvedHeaders);
+ AMod->MissingHeaders = translate(BMod.MissingHeaders);
+ AMod->Requirements = BMod.Requirements;
+ AMod->ShadowingModule = translate(BMod.ShadowingModule);
+ AMod->IsUnimportable = BMod.IsUnimportable;
+ AMod->HasIncompatibleModuleFile = BMod.HasIncompatibleModuleFile;
+ AMod->IsAvailable = BMod.IsAvailable;
+ AMod->IsFromModuleFile = BMod.IsFromModuleFile;
+ AMod->IsFramework = BMod.IsFramework;
+ AMod->IsExplicit = BMod.IsExplicit;
+ AMod->IsSystem = BMod.IsSystem;
+ AMod->IsExternC = BMod.IsExternC;
+ AMod->IsInferred = BMod.IsInferred;
+ AMod->InferSubmodules = BMod.InferSubmodules;
+ AMod->InferExplicitSubmodules = BMod.InferExplicitSubmodules;
+ AMod->InferExportWildcard = BMod.InferExportWildcard;
+ AMod->ConfigMacrosExhaustive = BMod.ConfigMacrosExhaustive;
+ AMod->NoUndeclaredIncludes = BMod.NoUndeclaredIncludes;
+ AMod->ModuleMapIsPrivate = BMod.ModuleMapIsPrivate;
+ AMod->NameVisibility = BMod.NameVisibility;
+ AMod->InferredSubmoduleLoc = translate(BMod.InferredSubmoduleLoc);
+ AMod->Imports = translate(BMod.Imports);
+ AMod->Exports = translate(BMod.Exports);
+ AMod->UnresolvedExports = translate(BMod.UnresolvedExports);
+ AMod->DirectUses = translate(BMod.DirectUses);
+ AMod->UnresolvedDirectUses = translate(BMod.UnresolvedDirectUses);
+ AMod->UndeclaredUses = translate(BMod.UndeclaredUses);
+ AMod->LinkLibraries = translate(BMod.LinkLibraries);
+ AMod->UseExportAsModuleLinkName = BMod.UseExportAsModuleLinkName;
+ AMod->ConfigMacros = BMod.ConfigMacros;
+ AMod->UnresolvedConflicts = BMod.UnresolvedConflicts;
+ AMod->Conflicts = BMod.Conflicts;
+
+ return *AMod;
+ }
+
+ void translateModule(StringRef BName) {
+ translate(B.getPreprocessor().getHeaderSearchInfo().lookupModule(BName));
+ }
+
+ IdentifierInfo *translate(IdentifierInfo *BII) {
+ auto &AII = APP.getIdentifierTable().getOwn(BII->getName());
+
+ AII.setOutOfDate(false);
+
+ // TODO: Check if is interesting.
+
+ if (BII->hasRevertedTokenIDToIdentifier() &&
+ BII->getTokenID() != tok::TokenKind::identifier)
+ AII.revertTokenIDToIdentifier();
+ AII.setObjCOrBuiltinID(BII->getObjCOrBuiltinID());
+ AII.setIsPoisoned(BII->isPoisoned());
+
+ AII.setObjCKeywordID(BII->getObjCKeywordID());
+ AII.setHasMacroDefinition(BII->hasMacroDefinition());
+
+ return &AII;
+ }
+
+ Token translate(const Token &BTok) {
+ Token ATok;
+ ATok.startToken();
+ ATok.setLocation(translate(BTok.getLocation()));
+ ATok.setLength(BTok.getLength());
+ ATok.setIdentifierInfo(translate(ATok.getIdentifierInfo()));
+ ATok.setKind(BTok.getKind());
+ ATok.setFlags(BTok.getFlags());
+ return ATok;
+ }
+
+ MacroInfo *translate(MacroInfo *BMI) {
+ auto BLoc = BMI->getDefinitionLoc();
+ auto ALoc = translate(BLoc);
+
+ MacroInfo *AMI = APP.AllocateMacroInfo(ALoc);
+ AMI->setDefinitionEndLoc(BMI->getDefinitionEndLoc());
+ AMI->setIsUsed(BMI->isUsed());
+ AMI->setUsedForHeaderGuard(BMI->isUsedForHeaderGuard());
+
+ if (BMI->isFunctionLike()) {
+ AMI->setIsFunctionLike();
+ if (BMI->isC99Varargs())
+ AMI->setIsC99Varargs();
+ if (BMI->isGNUVarargs())
+ AMI->setIsGNUVarargs();
+ if (BMI->hasCommaPasting())
+ AMI->setHasCommaPasting();
+ std::vector<IdentifierInfo *> AParams;
+ for (const IdentifierInfo *BParam : BMI->params())
+ AParams.push_back(translate(const_cast<IdentifierInfo *>(BParam)));
+ AMI->setParameterList(AParams, APP.getPreprocessorAllocator());
+ }
+
+ // TODO: Complete preprocessing record.
+
+ std::vector<Token> AToks;
+ for (const Token &BTok : BMI->tokens())
+ AToks.push_back(translate(BTok));
+ AMI->setTokens(AToks, APP.getPreprocessorAllocator());
+
+ return AMI;
+ }
+
+ void translatePreprocessor() {
+ for (const auto &Entry : BPP.getIdentifierTable()) {
+ IdentifierInfo *BII = Entry.getValue();
+
+ if (!BII->hadMacroDefinition())
+ continue;
+
+ // Macro directive history is not read for modules.
+
+ IdentifierInfo *BName = BII;
+ IdentifierInfo *AName = translate(BII);
+
+ auto BLeafs = BPP.getLeafModuleMacros(BName);
+ SmallVector<ModuleMacro *, 8> Worklist(BLeafs.begin(), BLeafs.end());
+ llvm::DenseMap<ModuleMacro *, unsigned> Visits;
+ while (!Worklist.empty()) {
+ auto *BMacro = Worklist.pop_back_val();
+
+ auto *AModule = translate(BMacro->getOwningModule());
+ auto *AMacroInfo = translate(BMacro->getMacroInfo());
+
+ std::vector<ModuleMacro *> AOverrides;
+ for (auto *BOverride : BMacro->overrides()) {
+ auto *AOverrideModule = translate(BOverride->getOwningModule());
+ AOverrides.push_back(APP.getModuleMacro(AOverrideModule, AName));
+ }
+
+ bool Inserted = false;
+ APP.addModuleMacro(AModule, AName, AMacroInfo, AOverrides, Inserted);
+
+ // Enqueue overridden macros once we've visited all their ancestors.
+ for (auto *BModuleMacro : BMacro->overrides())
+ if (++Visits[BModuleMacro] == BModuleMacro->getNumOverridingMacros())
+ Worklist.push_back(BModuleMacro);
+ }
+ }
+ }
+};
+
/// Compile a module file for the given module, using the options
/// provided by the importing compiler instance. Returns true if the module
/// was built without errors.
@@ -1254,6 +1592,48 @@
[&]() {
GenerateModuleFromModuleMapAction Action;
Instance.ExecuteAction(Action);
+
+ Translator T(ImportingInstance, Instance);
+ T.translateModule(ModuleName);
+ T.translatePreprocessor();
+
+ std::set<const FileEntry *> AffectingModuleMaps;
+ std::set<const FileEntry *> SkippedModuleMaps;
+
+ auto &SortedFiles = ImportingInstance.SortedFiles[ModuleName];
+ for (unsigned I = 1, N = SourceMgr.local_sloc_entry_size(); I != N; ++I) {
+ // Get this source location entry.
+ const SrcMgr::SLocEntry *SLoc = &SourceMgr.getLocalSLocEntry(I);
+
+ // We only care about file entries that were not overridden.
+ if (!SLoc->isFile())
+ continue;
+ const SrcMgr::FileInfo &File = SLoc->getFile();
+ const SrcMgr::ContentCache *Cache = &File.getContentCache();
+ if (!Cache->OrigEntry)
+ continue;
+
+ if (isModuleMap(File.getFileCharacteristic()) &&
+ !isSystem(File.getFileCharacteristic()) &&
+ !AffectingModuleMaps.empty() &&
+ AffectingModuleMaps.find(Cache->OrigEntry) ==
+ AffectingModuleMaps.end()) {
+ SkippedModuleMaps.insert(Cache->OrigEntry);
+ // Do not emit modulemaps that do not affect current module.
+ continue;
+ }
+
+ CompilerInstance::EntryStruct Entry{
+ T.translate(Cache->OrigEntry),
+ isSystem(File.getFileCharacteristic()),
+ isModuleMap(File.getFileCharacteristic()) &&
+ File.getIncludeLoc().isInvalid()};
+
+ if (Entry.IsSystemFile)
+ SortedFiles.push_back(Entry);
+ else
+ SortedFiles.push_front(Entry);
+ }
},
DesiredStackSize);
@@ -1364,6 +1744,9 @@
SourceLocation ModuleNameLoc,
Module *Module, StringRef ModuleFileName,
bool *OutOfDate) {
+ // Do not attempt to read the AST file.
+ return true;
+
DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
@@ -2092,7 +2475,7 @@
// Make the named module visible, if it's not already part of the module
// we are parsing.
if (ModuleName != getLangOpts().CurrentModule) {
- if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
+ if (false && !Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
// We have an umbrella header or directory that doesn't actually include
// all of the headers within the directory it covers. Complain about
// this missing submodule and recover by forgetting that we ever saw
Index: clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
===================================================================
--- clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
+++ clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h
@@ -87,9 +87,6 @@
/// additionally appear in \c FileDeps as a dependency.
std::string ClangModuleMapFile;
- /// The path to where an implicit build would put the PCM for this module.
- std::string ImplicitModulePCMPath;
-
/// A collection of absolute paths to files that this module directly depends
/// on, not including transitive dependencies.
llvm::StringSet<> FileDeps;
Index: clang/include/clang/Lex/Token.h
===================================================================
--- clang/include/clang/Lex/Token.h
+++ clang/include/clang/Lex/Token.h
@@ -246,7 +246,7 @@
Flags &= ~Flag;
}
- /// Return the internal represtation of the flags.
+ /// Return the internal representation of the flags.
///
/// This is only intended for low-level operations such as writing tokens to
/// disk.
@@ -254,6 +254,14 @@
return Flags;
}
+ /// Set the internal representation of the flags.
+ ///
+ /// This is only intended for low-level operations such as writing tokens to
+ /// disk.
+ void setFlags(unsigned Flags) {
+ this->Flags = Flags;
+ }
+
/// Set a flag to either true or false.
void setFlagValue(TokenFlags Flag, bool Val) {
if (Val)
Index: clang/include/clang/Frontend/CompilerInstance.h
===================================================================
--- clang/include/clang/Frontend/CompilerInstance.h
+++ clang/include/clang/Frontend/CompilerInstance.h
@@ -179,6 +179,13 @@
CompilerInstance(const CompilerInstance &) = delete;
void operator=(const CompilerInstance &) = delete;
public:
+ struct EntryStruct {
+ Optional<FileEntryRef> FE;
+ bool IsSystemFile;
+ bool IsTopLevelModuleMap;
+ };
+ llvm::StringMap<std::deque<EntryStruct>> SortedFiles;
+
explicit CompilerInstance(
std::shared_ptr<PCHContainerOperations> PCHContainerOps =
std::make_shared<PCHContainerOperations>(),
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
