1 //===-- ClangModulesDeclVendor.cpp ------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include <mutex>
10 
11 #include "clang/Basic/TargetInfo.h"
12 #include "clang/Frontend/CompilerInstance.h"
13 #include "clang/Frontend/FrontendActions.h"
14 #include "clang/Lex/Preprocessor.h"
15 #include "clang/Lex/PreprocessorOptions.h"
16 #include "clang/Parse/Parser.h"
17 #include "clang/Sema/Lookup.h"
18 #include "clang/Serialization/ASTReader.h"
19 #include "llvm/Support/FileSystem.h"
20 #include "llvm/Support/Path.h"
21 #include "llvm/Support/Threading.h"
22 
23 #include "ClangHost.h"
24 #include "ClangModulesDeclVendor.h"
25 #include "ModuleDependencyCollector.h"
26 
27 #include "lldb/Core/ModuleList.h"
28 #include "lldb/Host/Host.h"
29 #include "lldb/Host/HostInfo.h"
30 #include "lldb/Symbol/CompileUnit.h"
31 #include "lldb/Symbol/SourceModule.h"
32 #include "lldb/Target/Target.h"
33 #include "lldb/Utility/FileSpec.h"
34 #include "lldb/Utility/LLDBAssert.h"
35 #include "lldb/Utility/Log.h"
36 #include "lldb/Utility/Reproducer.h"
37 #include "lldb/Utility/StreamString.h"
38 
39 using namespace lldb_private;
40 
41 namespace {
42 // Any Clang compiler requires a consumer for diagnostics.  This one stores
43 // them as strings so we can provide them to the user in case a module failed
44 // to load.
45 class StoringDiagnosticConsumer : public clang::DiagnosticConsumer {
46 public:
47   StoringDiagnosticConsumer();
48 
49   void HandleDiagnostic(clang::DiagnosticsEngine::Level DiagLevel,
50                         const clang::Diagnostic &info) override;
51 
52   void ClearDiagnostics();
53 
54   void DumpDiagnostics(Stream &error_stream);
55 
56 private:
57   typedef std::pair<clang::DiagnosticsEngine::Level, std::string>
58       IDAndDiagnostic;
59   std::vector<IDAndDiagnostic> m_diagnostics;
60   Log *m_log;
61 };
62 
63 // The private implementation of our ClangModulesDeclVendor.  Contains all the
64 // Clang state required to load modules.
65 class ClangModulesDeclVendorImpl : public ClangModulesDeclVendor {
66 public:
67   ClangModulesDeclVendorImpl(
68       llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
69       std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
70       std::unique_ptr<clang::CompilerInstance> compiler_instance,
71       std::unique_ptr<clang::Parser> parser);
72 
73   ~ClangModulesDeclVendorImpl() override = default;
74 
75   bool AddModule(const SourceModule &module, ModuleVector *exported_modules,
76                  Stream &error_stream) override;
77 
78   bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules,
79                                 Stream &error_stream) override;
80 
81   uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
82                      std::vector<clang::NamedDecl *> &decls) override;
83 
84   void ForEachMacro(const ModuleVector &modules,
85                     std::function<bool(const std::string &)> handler) override;
86 
87   clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
88 private:
89   void
90   ReportModuleExportsHelper(std::set<ClangModulesDeclVendor::ModuleID> &exports,
91                             clang::Module *module);
92 
93   void ReportModuleExports(ModuleVector &exports, clang::Module *module);
94 
95   clang::ModuleLoadResult DoGetModule(clang::ModuleIdPath path,
96                                       bool make_visible);
97 
98   bool m_enabled = false;
99 
100   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> m_diagnostics_engine;
101   std::shared_ptr<clang::CompilerInvocation> m_compiler_invocation;
102   std::unique_ptr<clang::CompilerInstance> m_compiler_instance;
103   std::unique_ptr<clang::Parser> m_parser;
104   size_t m_source_location_index =
105       0; // used to give name components fake SourceLocations
106 
107   typedef std::vector<ConstString> ImportedModule;
108   typedef std::map<ImportedModule, clang::Module *> ImportedModuleMap;
109   typedef std::set<ModuleID> ImportedModuleSet;
110   ImportedModuleMap m_imported_modules;
111   ImportedModuleSet m_user_imported_modules;
112   const clang::ExternalASTMerger::OriginMap m_origin_map;
113 };
114 } // anonymous namespace
115 
116 StoringDiagnosticConsumer::StoringDiagnosticConsumer() {
117   m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
118 }
119 
120 void StoringDiagnosticConsumer::HandleDiagnostic(
121     clang::DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info) {
122   llvm::SmallVector<char, 256> diagnostic_string;
123 
124   info.FormatDiagnostic(diagnostic_string);
125 
126   m_diagnostics.push_back(
127       IDAndDiagnostic(DiagLevel, std::string(diagnostic_string.data(),
128                                              diagnostic_string.size())));
129 }
130 
131 void StoringDiagnosticConsumer::ClearDiagnostics() { m_diagnostics.clear(); }
132 
133 void StoringDiagnosticConsumer::DumpDiagnostics(Stream &error_stream) {
134   for (IDAndDiagnostic &diag : m_diagnostics) {
135     switch (diag.first) {
136     default:
137       error_stream.PutCString(diag.second);
138       error_stream.PutChar('\n');
139       break;
140     case clang::DiagnosticsEngine::Level::Ignored:
141       break;
142     }
143   }
144 }
145 
146 ClangModulesDeclVendor::ClangModulesDeclVendor() {}
147 
148 ClangModulesDeclVendor::~ClangModulesDeclVendor() {}
149 
150 ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
151     llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
152     std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
153     std::unique_ptr<clang::CompilerInstance> compiler_instance,
154     std::unique_ptr<clang::Parser> parser)
155     : m_diagnostics_engine(std::move(diagnostics_engine)),
156       m_compiler_invocation(std::move(compiler_invocation)),
157       m_compiler_instance(std::move(compiler_instance)),
158       m_parser(std::move(parser)), m_origin_map() {}
159 
160 void ClangModulesDeclVendorImpl::ReportModuleExportsHelper(
161     std::set<ClangModulesDeclVendor::ModuleID> &exports,
162     clang::Module *module) {
163   if (exports.count(reinterpret_cast<ClangModulesDeclVendor::ModuleID>(module)))
164     return;
165 
166   exports.insert(reinterpret_cast<ClangModulesDeclVendor::ModuleID>(module));
167 
168   llvm::SmallVector<clang::Module *, 2> sub_exports;
169 
170   module->getExportedModules(sub_exports);
171 
172   for (clang::Module *module : sub_exports) {
173     ReportModuleExportsHelper(exports, module);
174   }
175 }
176 
177 void ClangModulesDeclVendorImpl::ReportModuleExports(
178     ClangModulesDeclVendor::ModuleVector &exports, clang::Module *module) {
179   std::set<ClangModulesDeclVendor::ModuleID> exports_set;
180 
181   ReportModuleExportsHelper(exports_set, module);
182 
183   for (ModuleID module : exports_set) {
184     exports.push_back(module);
185   }
186 }
187 
188 bool ClangModulesDeclVendorImpl::AddModule(const SourceModule &module,
189                                            ModuleVector *exported_modules,
190                                            Stream &error_stream) {
191   // Fail early.
192 
193   if (m_compiler_instance->hadModuleLoaderFatalFailure()) {
194     error_stream.PutCString("error: Couldn't load a module because the module "
195                             "loader is in a fatal state.\n");
196     return false;
197   }
198 
199   // Check if we've already imported this module.
200 
201   std::vector<ConstString> imported_module;
202 
203   for (ConstString path_component : module.path) {
204     imported_module.push_back(path_component);
205   }
206 
207   {
208     ImportedModuleMap::iterator mi = m_imported_modules.find(imported_module);
209 
210     if (mi != m_imported_modules.end()) {
211       if (exported_modules) {
212         ReportModuleExports(*exported_modules, mi->second);
213       }
214       return true;
215     }
216   }
217 
218   clang::HeaderSearch &HS =
219     m_compiler_instance->getPreprocessor().getHeaderSearchInfo();
220 
221   if (module.search_path) {
222     auto path_begin = llvm::sys::path::begin(module.search_path.GetStringRef());
223     auto path_end = llvm::sys::path::end(module.search_path.GetStringRef());
224     auto sysroot_begin = llvm::sys::path::begin(module.sysroot.GetStringRef());
225     auto sysroot_end = llvm::sys::path::end(module.sysroot.GetStringRef());
226     // FIXME: Use C++14 std::equal(it, it, it, it) variant once it's available.
227     bool is_system_module = (std::distance(path_begin, path_end) >=
228                              std::distance(sysroot_begin, sysroot_end)) &&
229                             std::equal(sysroot_begin, sysroot_end, path_begin);
230     // No need to inject search paths to modules in the sysroot.
231     if (!is_system_module) {
232       auto error = [&]() {
233         error_stream.Printf("error: No module map file in %s\n",
234                             module.search_path.AsCString());
235         return false;
236       };
237 
238       bool is_system = true;
239       bool is_framework = false;
240       auto *dir =
241           HS.getFileMgr().getDirectory(module.search_path.GetStringRef());
242       if (!dir)
243         return error();
244       auto *file = HS.lookupModuleMapFile(dir, is_framework);
245       if (!file)
246         return error();
247       if (!HS.loadModuleMapFile(file, is_system))
248         return error();
249     }
250   }
251   if (!HS.lookupModule(module.path.front().GetStringRef())) {
252     error_stream.Printf("error: Header search couldn't locate module %s\n",
253                         module.path.front().AsCString());
254     return false;
255   }
256 
257   llvm::SmallVector<std::pair<clang::IdentifierInfo *, clang::SourceLocation>,
258                     4>
259       clang_path;
260 
261   {
262     clang::SourceManager &source_manager =
263         m_compiler_instance->getASTContext().getSourceManager();
264 
265     for (ConstString path_component : module.path) {
266       clang_path.push_back(std::make_pair(
267           &m_compiler_instance->getASTContext().Idents.get(
268               path_component.GetStringRef()),
269           source_manager.getLocForStartOfFile(source_manager.getMainFileID())
270               .getLocWithOffset(m_source_location_index++)));
271     }
272   }
273 
274   StoringDiagnosticConsumer *diagnostic_consumer =
275       static_cast<StoringDiagnosticConsumer *>(
276           m_compiler_instance->getDiagnostics().getClient());
277 
278   diagnostic_consumer->ClearDiagnostics();
279 
280   clang::Module *top_level_module = DoGetModule(clang_path.front(), false);
281 
282   if (!top_level_module) {
283     diagnostic_consumer->DumpDiagnostics(error_stream);
284     error_stream.Printf("error: Couldn't load top-level module %s\n",
285                         module.path.front().AsCString());
286     return false;
287   }
288 
289   clang::Module *submodule = top_level_module;
290 
291   for (auto &component : llvm::ArrayRef<ConstString>(module.path).drop_front()) {
292     submodule = submodule->findSubmodule(component.GetStringRef());
293     if (!submodule) {
294       diagnostic_consumer->DumpDiagnostics(error_stream);
295       error_stream.Printf("error: Couldn't load submodule %s\n",
296                           component.GetCString());
297       return false;
298     }
299   }
300 
301   clang::Module *requested_module = DoGetModule(clang_path, true);
302 
303   if (requested_module != nullptr) {
304     if (exported_modules) {
305       ReportModuleExports(*exported_modules, requested_module);
306     }
307 
308     m_imported_modules[imported_module] = requested_module;
309 
310     m_enabled = true;
311 
312     return true;
313   }
314 
315   return false;
316 }
317 
318 bool ClangModulesDeclVendor::LanguageSupportsClangModules(
319     lldb::LanguageType language) {
320   switch (language) {
321   default:
322     return false;
323   case lldb::LanguageType::eLanguageTypeC:
324   case lldb::LanguageType::eLanguageTypeC11:
325   case lldb::LanguageType::eLanguageTypeC89:
326   case lldb::LanguageType::eLanguageTypeC99:
327   case lldb::LanguageType::eLanguageTypeC_plus_plus:
328   case lldb::LanguageType::eLanguageTypeC_plus_plus_03:
329   case lldb::LanguageType::eLanguageTypeC_plus_plus_11:
330   case lldb::LanguageType::eLanguageTypeC_plus_plus_14:
331   case lldb::LanguageType::eLanguageTypeObjC:
332   case lldb::LanguageType::eLanguageTypeObjC_plus_plus:
333     return true;
334   }
335 }
336 
337 bool ClangModulesDeclVendorImpl::AddModulesForCompileUnit(
338     CompileUnit &cu, ClangModulesDeclVendor::ModuleVector &exported_modules,
339     Stream &error_stream) {
340   if (LanguageSupportsClangModules(cu.GetLanguage())) {
341     for (auto &imported_module : cu.GetImportedModules())
342       if (!AddModule(imported_module, &exported_modules, error_stream))
343         return false;
344   }
345   return true;
346 }
347 
348 // ClangImporter::lookupValue
349 
350 uint32_t
351 ClangModulesDeclVendorImpl::FindDecls(ConstString name, bool append,
352                                       uint32_t max_matches,
353                                       std::vector<clang::NamedDecl *> &decls) {
354   if (!m_enabled) {
355     return 0;
356   }
357 
358   if (!append)
359     decls.clear();
360 
361   clang::IdentifierInfo &ident =
362       m_compiler_instance->getASTContext().Idents.get(name.GetStringRef());
363 
364   clang::LookupResult lookup_result(
365       m_compiler_instance->getSema(), clang::DeclarationName(&ident),
366       clang::SourceLocation(), clang::Sema::LookupOrdinaryName);
367 
368   m_compiler_instance->getSema().LookupName(
369       lookup_result,
370       m_compiler_instance->getSema().getScopeForContext(
371           m_compiler_instance->getASTContext().getTranslationUnitDecl()));
372 
373   uint32_t num_matches = 0;
374 
375   for (clang::NamedDecl *named_decl : lookup_result) {
376     if (num_matches >= max_matches)
377       return num_matches;
378 
379     decls.push_back(named_decl);
380     ++num_matches;
381   }
382 
383   return num_matches;
384 }
385 
386 void ClangModulesDeclVendorImpl::ForEachMacro(
387     const ClangModulesDeclVendor::ModuleVector &modules,
388     std::function<bool(const std::string &)> handler) {
389   if (!m_enabled) {
390     return;
391   }
392 
393   typedef std::map<ModuleID, ssize_t> ModulePriorityMap;
394   ModulePriorityMap module_priorities;
395 
396   ssize_t priority = 0;
397 
398   for (ModuleID module : modules) {
399     module_priorities[module] = priority++;
400   }
401 
402   if (m_compiler_instance->getPreprocessor().getExternalSource()) {
403     m_compiler_instance->getPreprocessor()
404         .getExternalSource()
405         ->ReadDefinedMacros();
406   }
407 
408   for (clang::Preprocessor::macro_iterator
409            mi = m_compiler_instance->getPreprocessor().macro_begin(),
410            me = m_compiler_instance->getPreprocessor().macro_end();
411        mi != me; ++mi) {
412     const clang::IdentifierInfo *ii = nullptr;
413 
414     {
415       if (clang::IdentifierInfoLookup *lookup =
416               m_compiler_instance->getPreprocessor()
417                   .getIdentifierTable()
418                   .getExternalIdentifierLookup()) {
419         lookup->get(mi->first->getName());
420       }
421       if (!ii) {
422         ii = mi->first;
423       }
424     }
425 
426     ssize_t found_priority = -1;
427     clang::MacroInfo *macro_info = nullptr;
428 
429     for (clang::ModuleMacro *module_macro :
430          m_compiler_instance->getPreprocessor().getLeafModuleMacros(ii)) {
431       clang::Module *module = module_macro->getOwningModule();
432 
433       {
434         ModulePriorityMap::iterator pi =
435             module_priorities.find(reinterpret_cast<ModuleID>(module));
436 
437         if (pi != module_priorities.end() && pi->second > found_priority) {
438           macro_info = module_macro->getMacroInfo();
439           found_priority = pi->second;
440         }
441       }
442 
443       clang::Module *top_level_module = module->getTopLevelModule();
444 
445       if (top_level_module != module) {
446         ModulePriorityMap::iterator pi = module_priorities.find(
447             reinterpret_cast<ModuleID>(top_level_module));
448 
449         if ((pi != module_priorities.end()) && pi->second > found_priority) {
450           macro_info = module_macro->getMacroInfo();
451           found_priority = pi->second;
452         }
453       }
454     }
455 
456     if (macro_info) {
457       std::string macro_expansion = "#define ";
458       macro_expansion.append(mi->first->getName().str());
459 
460       {
461         if (macro_info->isFunctionLike()) {
462           macro_expansion.append("(");
463 
464           bool first_arg = true;
465 
466           for (auto pi = macro_info->param_begin(),
467                     pe = macro_info->param_end();
468                pi != pe; ++pi) {
469             if (!first_arg) {
470               macro_expansion.append(", ");
471             } else {
472               first_arg = false;
473             }
474 
475             macro_expansion.append((*pi)->getName().str());
476           }
477 
478           if (macro_info->isC99Varargs()) {
479             if (first_arg) {
480               macro_expansion.append("...");
481             } else {
482               macro_expansion.append(", ...");
483             }
484           } else if (macro_info->isGNUVarargs()) {
485             macro_expansion.append("...");
486           }
487 
488           macro_expansion.append(")");
489         }
490 
491         macro_expansion.append(" ");
492 
493         bool first_token = true;
494 
495         for (clang::MacroInfo::tokens_iterator ti = macro_info->tokens_begin(),
496                                                te = macro_info->tokens_end();
497              ti != te; ++ti) {
498           if (!first_token) {
499             macro_expansion.append(" ");
500           } else {
501             first_token = false;
502           }
503 
504           if (ti->isLiteral()) {
505             if (const char *literal_data = ti->getLiteralData()) {
506               std::string token_str(literal_data, ti->getLength());
507               macro_expansion.append(token_str);
508             } else {
509               bool invalid = false;
510               const char *literal_source =
511                   m_compiler_instance->getSourceManager().getCharacterData(
512                       ti->getLocation(), &invalid);
513 
514               if (invalid) {
515                 lldbassert(0 && "Unhandled token kind");
516                 macro_expansion.append("<unknown literal value>");
517               } else {
518                 macro_expansion.append(
519                     std::string(literal_source, ti->getLength()));
520               }
521             }
522           } else if (const char *punctuator_spelling =
523                          clang::tok::getPunctuatorSpelling(ti->getKind())) {
524             macro_expansion.append(punctuator_spelling);
525           } else if (const char *keyword_spelling =
526                          clang::tok::getKeywordSpelling(ti->getKind())) {
527             macro_expansion.append(keyword_spelling);
528           } else {
529             switch (ti->getKind()) {
530             case clang::tok::TokenKind::identifier:
531               macro_expansion.append(ti->getIdentifierInfo()->getName().str());
532               break;
533             case clang::tok::TokenKind::raw_identifier:
534               macro_expansion.append(ti->getRawIdentifier().str());
535               break;
536             default:
537               macro_expansion.append(ti->getName());
538               break;
539             }
540           }
541         }
542 
543         if (handler(macro_expansion)) {
544           return;
545         }
546       }
547     }
548   }
549 }
550 
551 clang::ModuleLoadResult
552 ClangModulesDeclVendorImpl::DoGetModule(clang::ModuleIdPath path,
553                                         bool make_visible) {
554   clang::Module::NameVisibilityKind visibility =
555       make_visible ? clang::Module::AllVisible : clang::Module::Hidden;
556 
557   const bool is_inclusion_directive = false;
558 
559   return m_compiler_instance->loadModule(path.front().second, path, visibility,
560                                          is_inclusion_directive);
561 }
562 
563 clang::ExternalASTMerger::ImporterSource
564 ClangModulesDeclVendorImpl::GetImporterSource() {
565   return {m_compiler_instance->getASTContext(),
566           m_compiler_instance->getFileManager(), m_origin_map};
567 }
568 
569 static const char *ModuleImportBufferName = "LLDBModulesMemoryBuffer";
570 
571 lldb_private::ClangModulesDeclVendor *
572 ClangModulesDeclVendor::Create(Target &target) {
573   // FIXME we should insure programmatically that the expression parser's
574   // compiler and the modules runtime's
575   // compiler are both initialized in the same way – preferably by the same
576   // code.
577 
578   if (!target.GetPlatform()->SupportsModules())
579     return nullptr;
580 
581   const ArchSpec &arch = target.GetArchitecture();
582 
583   std::vector<std::string> compiler_invocation_arguments = {
584       "clang",
585       "-fmodules",
586       "-fimplicit-module-maps",
587       "-fcxx-modules",
588       "-fsyntax-only",
589       "-femit-all-decls",
590       "-target",
591       arch.GetTriple().str(),
592       "-fmodules-validate-system-headers",
593       "-Werror=non-modular-include-in-framework-module"};
594 
595   target.GetPlatform()->AddClangModuleCompilationOptions(
596       &target, compiler_invocation_arguments);
597 
598   compiler_invocation_arguments.push_back(ModuleImportBufferName);
599 
600   // Add additional search paths with { "-I", path } or { "-F", path } here.
601 
602   {
603     llvm::SmallString<128> path;
604     auto props = ModuleList::GetGlobalModuleListProperties();
605     props.GetClangModulesCachePath().GetPath(path);
606     std::string module_cache_argument("-fmodules-cache-path=");
607     module_cache_argument.append(path.str());
608     compiler_invocation_arguments.push_back(module_cache_argument);
609   }
610 
611   FileSpecList module_search_paths = target.GetClangModuleSearchPaths();
612 
613   for (size_t spi = 0, spe = module_search_paths.GetSize(); spi < spe; ++spi) {
614     const FileSpec &search_path = module_search_paths.GetFileSpecAtIndex(spi);
615 
616     std::string search_path_argument = "-I";
617     search_path_argument.append(search_path.GetPath());
618 
619     compiler_invocation_arguments.push_back(search_path_argument);
620   }
621 
622   {
623     FileSpec clang_resource_dir = GetClangResourceDir();
624 
625     if (FileSystem::Instance().IsDirectory(clang_resource_dir.GetPath())) {
626       compiler_invocation_arguments.push_back("-resource-dir");
627       compiler_invocation_arguments.push_back(clang_resource_dir.GetPath());
628     }
629   }
630 
631   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine =
632       clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions,
633                                                  new StoringDiagnosticConsumer);
634 
635   std::vector<const char *> compiler_invocation_argument_cstrs;
636   compiler_invocation_argument_cstrs.reserve(
637       compiler_invocation_arguments.size());
638   for (const std::string &arg : compiler_invocation_arguments)
639     compiler_invocation_argument_cstrs.push_back(arg.c_str());
640 
641   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
642   LLDB_LOG(log, "ClangModulesDeclVendor's compiler flags {0:$[ ]}",
643            llvm::make_range(compiler_invocation_arguments.begin(),
644                             compiler_invocation_arguments.end()));
645 
646   std::shared_ptr<clang::CompilerInvocation> invocation =
647       clang::createInvocationFromCommandLine(compiler_invocation_argument_cstrs,
648                                              diagnostics_engine);
649 
650   if (!invocation)
651     return nullptr;
652 
653   std::unique_ptr<llvm::MemoryBuffer> source_buffer =
654       llvm::MemoryBuffer::getMemBuffer(
655           "extern int __lldb __attribute__((unavailable));",
656           ModuleImportBufferName);
657 
658   invocation->getPreprocessorOpts().addRemappedFile(ModuleImportBufferName,
659                                                     source_buffer.release());
660 
661   std::unique_ptr<clang::CompilerInstance> instance(
662       new clang::CompilerInstance);
663 
664   // When capturing a reproducer, hook up the file collector with clang to
665   // collector modules and headers.
666   if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
667     repro::FileProvider &fp = g->GetOrCreate<repro::FileProvider>();
668     instance->setModuleDepCollector(
669         std::make_shared<ModuleDependencyCollectorAdaptor>(
670             fp.GetFileCollector()));
671     clang::DependencyOutputOptions &opts = instance->getDependencyOutputOpts();
672     opts.IncludeSystemHeaders = true;
673     opts.IncludeModuleFiles = true;
674   }
675 
676   // Make sure clang uses the same VFS as LLDB.
677   instance->createFileManager(FileSystem::Instance().GetVirtualFileSystem());
678   instance->setDiagnostics(diagnostics_engine.get());
679   instance->setInvocation(invocation);
680 
681   std::unique_ptr<clang::FrontendAction> action(new clang::SyntaxOnlyAction);
682 
683   instance->setTarget(clang::TargetInfo::CreateTargetInfo(
684       *diagnostics_engine, instance->getInvocation().TargetOpts));
685 
686   if (!instance->hasTarget())
687     return nullptr;
688 
689   instance->getTarget().adjust(instance->getLangOpts());
690 
691   if (!action->BeginSourceFile(*instance,
692                                instance->getFrontendOpts().Inputs[0]))
693     return nullptr;
694 
695   instance->getPreprocessor().enableIncrementalProcessing();
696 
697   instance->createModuleManager();
698 
699   instance->createSema(action->getTranslationUnitKind(), nullptr);
700 
701   const bool skipFunctionBodies = false;
702   std::unique_ptr<clang::Parser> parser(new clang::Parser(
703       instance->getPreprocessor(), instance->getSema(), skipFunctionBodies));
704 
705   instance->getPreprocessor().EnterMainSourceFile();
706   parser->Initialize();
707 
708   clang::Parser::DeclGroupPtrTy parsed;
709 
710   while (!parser->ParseTopLevelDecl(parsed))
711     ;
712 
713   return new ClangModulesDeclVendorImpl(std::move(diagnostics_engine),
714                                         std::move(invocation),
715                                         std::move(instance), std::move(parser));
716 }
717