clang  9.0.0svn
CompilerInstance.h
Go to the documentation of this file.
1 //===-- CompilerInstance.h - Clang Compiler Instance ------------*- 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 #ifndef LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
10 #define LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
11 
12 #include "clang/AST/ASTConsumer.h"
13 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Frontend/Utils.h"
19 #include "clang/Lex/ModuleLoader.h"
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/IntrusiveRefCntPtr.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/Support/BuryPointer.h"
25 #include <cassert>
26 #include <list>
27 #include <memory>
28 #include <string>
29 #include <utility>
30 
31 namespace llvm {
32 class raw_fd_ostream;
33 class Timer;
34 class TimerGroup;
35 }
36 
37 namespace clang {
38 class ASTContext;
39 class ASTReader;
40 class CodeCompleteConsumer;
41 class DiagnosticsEngine;
42 class DiagnosticConsumer;
43 class ExternalASTSource;
44 class FileEntry;
45 class FileManager;
46 class FrontendAction;
47 class InMemoryModuleCache;
48 class Module;
49 class Preprocessor;
50 class Sema;
51 class SourceManager;
52 class TargetInfo;
53 
54 /// CompilerInstance - Helper class for managing a single instance of the Clang
55 /// compiler.
56 ///
57 /// The CompilerInstance serves two purposes:
58 /// (1) It manages the various objects which are necessary to run the compiler,
59 /// for example the preprocessor, the target information, and the AST
60 /// context.
61 /// (2) It provides utility routines for constructing and manipulating the
62 /// common Clang objects.
63 ///
64 /// The compiler instance generally owns the instance of all the objects that it
65 /// manages. However, clients can still share objects by manually setting the
66 /// object and retaking ownership prior to destroying the CompilerInstance.
67 ///
68 /// The compiler instance is intended to simplify clients, but not to lock them
69 /// in to the compiler instance for everything. When possible, utility functions
70 /// come in two forms; a short form that reuses the CompilerInstance objects,
71 /// and a long form that takes explicit instances of any required objects.
73  /// The options used in this compiler instance.
74  std::shared_ptr<CompilerInvocation> Invocation;
75 
76  /// The diagnostics engine instance.
78 
79  /// The target being compiled for.
81 
82  /// Auxiliary Target info.
84 
85  /// The file manager.
87 
88  /// The source manager.
90 
91  /// The cache of PCM files.
93 
94  /// The preprocessor.
95  std::shared_ptr<Preprocessor> PP;
96 
97  /// The AST context.
99 
100  /// An optional sema source that will be attached to sema.
102 
103  /// The AST consumer.
104  std::unique_ptr<ASTConsumer> Consumer;
105 
106  /// The code completion consumer.
107  std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;
108 
109  /// The semantic analysis object.
110  std::unique_ptr<Sema> TheSema;
111 
112  /// The frontend timer group.
113  std::unique_ptr<llvm::TimerGroup> FrontendTimerGroup;
114 
115  /// The frontend timer.
116  std::unique_ptr<llvm::Timer> FrontendTimer;
117 
118  /// The ASTReader, if one exists.
119  IntrusiveRefCntPtr<ASTReader> ModuleManager;
120 
121  /// The module dependency collector for crashdumps
122  std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector;
123 
124  /// The module provider.
125  std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations;
126 
127  /// The dependency file generator.
128  std::unique_ptr<DependencyFileGenerator> TheDependencyFileGenerator;
129 
130  std::vector<std::shared_ptr<DependencyCollector>> DependencyCollectors;
131 
132  /// The set of top-level modules that has already been loaded,
133  /// along with the module map
134  llvm::DenseMap<const IdentifierInfo *, Module *> KnownModules;
135 
136  /// The set of top-level modules that has already been built on the
137  /// fly as part of this overall compilation action.
138  std::map<std::string, std::string> BuiltModules;
139 
140  /// Should we delete the BuiltModules when we're done?
141  bool DeleteBuiltModules = true;
142 
143  /// The location of the module-import keyword for the last module
144  /// import.
145  SourceLocation LastModuleImportLoc;
146 
147  /// The result of the last module import.
148  ///
149  ModuleLoadResult LastModuleImportResult;
150 
151  /// Whether we should (re)build the global module index once we
152  /// have finished with this translation unit.
153  bool BuildGlobalModuleIndex = false;
154 
155  /// We have a full global module index, with all modules.
156  bool HaveFullGlobalModuleIndex = false;
157 
158  /// One or more modules failed to build.
159  bool ModuleBuildFailed = false;
160 
161  /// Holds information about the output file.
162  ///
163  /// If TempFilename is not empty we must rename it to Filename at the end.
164  /// TempFilename may be empty and Filename non-empty if creating the temporary
165  /// failed.
166  struct OutputFile {
167  std::string Filename;
168  std::string TempFilename;
169 
170  OutputFile(std::string filename, std::string tempFilename)
171  : Filename(std::move(filename)), TempFilename(std::move(tempFilename)) {
172  }
173  };
174 
175  /// If the output doesn't support seeking (terminal, pipe). we switch
176  /// the stream to a buffer_ostream. These are the buffer and the original
177  /// stream.
178  std::unique_ptr<llvm::raw_fd_ostream> NonSeekStream;
179 
180  /// The list of active output files.
181  std::list<OutputFile> OutputFiles;
182 
183  /// Force an output buffer.
184  std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;
185 
186  CompilerInstance(const CompilerInstance &) = delete;
187  void operator=(const CompilerInstance &) = delete;
188 public:
189  explicit CompilerInstance(
190  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
191  std::make_shared<PCHContainerOperations>(),
192  InMemoryModuleCache *SharedModuleCache = nullptr);
193  ~CompilerInstance() override;
194 
195  /// @name High-Level Operations
196  /// {
197 
198  /// ExecuteAction - Execute the provided action against the compiler's
199  /// CompilerInvocation object.
200  ///
201  /// This function makes the following assumptions:
202  ///
203  /// - The invocation options should be initialized. This function does not
204  /// handle the '-help' or '-version' options, clients should handle those
205  /// directly.
206  ///
207  /// - The diagnostics engine should have already been created by the client.
208  ///
209  /// - No other CompilerInstance state should have been initialized (this is
210  /// an unchecked error).
211  ///
212  /// - Clients should have initialized any LLVM target features that may be
213  /// required.
214  ///
215  /// - Clients should eventually call llvm_shutdown() upon the completion of
216  /// this routine to ensure that any managed objects are properly destroyed.
217  ///
218  /// Note that this routine may write output to 'stderr'.
219  ///
220  /// \param Act - The action to execute.
221  /// \return - True on success.
222  //
223  // FIXME: This function should take the stream to write any debugging /
224  // verbose output to as an argument.
225  //
226  // FIXME: Eliminate the llvm_shutdown requirement, that should either be part
227  // of the context or else not CompilerInstance specific.
228  bool ExecuteAction(FrontendAction &Act);
229 
230  /// }
231  /// @name Compiler Invocation and Options
232  /// {
233 
234  bool hasInvocation() const { return Invocation != nullptr; }
235 
237  assert(Invocation && "Compiler instance has no invocation!");
238  return *Invocation;
239  }
240 
241  /// setInvocation - Replace the current invocation.
242  void setInvocation(std::shared_ptr<CompilerInvocation> Value);
243 
244  /// Indicates whether we should (re)build the global module index.
245  bool shouldBuildGlobalModuleIndex() const;
246 
247  /// Set the flag indicating whether we should (re)build the global
248  /// module index.
249  void setBuildGlobalModuleIndex(bool Build) {
250  BuildGlobalModuleIndex = Build;
251  }
252 
253  /// }
254  /// @name Forwarding Methods
255  /// {
256 
258  return Invocation->getAnalyzerOpts();
259  }
260 
262  return Invocation->getCodeGenOpts();
263  }
265  return Invocation->getCodeGenOpts();
266  }
267 
269  return Invocation->getDependencyOutputOpts();
270  }
272  return Invocation->getDependencyOutputOpts();
273  }
274 
276  return Invocation->getDiagnosticOpts();
277  }
279  return Invocation->getDiagnosticOpts();
280  }
281 
283  return Invocation->getFileSystemOpts();
284  }
286  return Invocation->getFileSystemOpts();
287  }
288 
290  return Invocation->getFrontendOpts();
291  }
293  return Invocation->getFrontendOpts();
294  }
295 
297  return Invocation->getHeaderSearchOpts();
298  }
300  return Invocation->getHeaderSearchOpts();
301  }
302  std::shared_ptr<HeaderSearchOptions> getHeaderSearchOptsPtr() const {
303  return Invocation->getHeaderSearchOptsPtr();
304  }
305 
307  return *Invocation->getLangOpts();
308  }
309  const LangOptions &getLangOpts() const {
310  return *Invocation->getLangOpts();
311  }
312 
314  return Invocation->getPreprocessorOpts();
315  }
317  return Invocation->getPreprocessorOpts();
318  }
319 
321  return Invocation->getPreprocessorOutputOpts();
322  }
324  return Invocation->getPreprocessorOutputOpts();
325  }
326 
328  return Invocation->getTargetOpts();
329  }
330  const TargetOptions &getTargetOpts() const {
331  return Invocation->getTargetOpts();
332  }
333 
334  /// }
335  /// @name Diagnostics Engine
336  /// {
337 
338  bool hasDiagnostics() const { return Diagnostics != nullptr; }
339 
340  /// Get the current diagnostics engine.
342  assert(Diagnostics && "Compiler instance has no diagnostics!");
343  return *Diagnostics;
344  }
345 
346  /// setDiagnostics - Replace the current diagnostics engine.
347  void setDiagnostics(DiagnosticsEngine *Value);
348 
350  assert(Diagnostics && Diagnostics->getClient() &&
351  "Compiler instance has no diagnostic client!");
352  return *Diagnostics->getClient();
353  }
354 
355  /// }
356  /// @name Target Info
357  /// {
358 
359  bool hasTarget() const { return Target != nullptr; }
360 
362  assert(Target && "Compiler instance has no target!");
363  return *Target;
364  }
365 
366  /// Replace the current Target.
367  void setTarget(TargetInfo *Value);
368 
369  /// }
370  /// @name AuxTarget Info
371  /// {
372 
373  TargetInfo *getAuxTarget() const { return AuxTarget.get(); }
374 
375  /// Replace the current AuxTarget.
376  void setAuxTarget(TargetInfo *Value);
377 
378  /// }
379  /// @name Virtual File System
380  /// {
381 
382  llvm::vfs::FileSystem &getVirtualFileSystem() const {
383  return getFileManager().getVirtualFileSystem();
384  }
385 
386  /// }
387  /// @name File Manager
388  /// {
389 
390  bool hasFileManager() const { return FileMgr != nullptr; }
391 
392  /// Return the current file manager to the caller.
394  assert(FileMgr && "Compiler instance has no file manager!");
395  return *FileMgr;
396  }
397 
399  llvm::BuryPointer(FileMgr.get());
400  FileMgr.resetWithoutRelease();
401  }
402 
403  /// Replace the current file manager and virtual file system.
404  void setFileManager(FileManager *Value);
405 
406  /// }
407  /// @name Source Manager
408  /// {
409 
410  bool hasSourceManager() const { return SourceMgr != nullptr; }
411 
412  /// Return the current source manager.
414  assert(SourceMgr && "Compiler instance has no source manager!");
415  return *SourceMgr;
416  }
417 
419  llvm::BuryPointer(SourceMgr.get());
420  SourceMgr.resetWithoutRelease();
421  }
422 
423  /// setSourceManager - Replace the current source manager.
424  void setSourceManager(SourceManager *Value);
425 
426  /// }
427  /// @name Preprocessor
428  /// {
429 
430  bool hasPreprocessor() const { return PP != nullptr; }
431 
432  /// Return the current preprocessor.
434  assert(PP && "Compiler instance has no preprocessor!");
435  return *PP;
436  }
437 
438  std::shared_ptr<Preprocessor> getPreprocessorPtr() { return PP; }
439 
441  llvm::BuryPointer(new std::shared_ptr<Preprocessor>(PP));
442  }
443 
444  /// Replace the current preprocessor.
445  void setPreprocessor(std::shared_ptr<Preprocessor> Value);
446 
447  /// }
448  /// @name ASTContext
449  /// {
450 
451  bool hasASTContext() const { return Context != nullptr; }
452 
454  assert(Context && "Compiler instance has no AST context!");
455  return *Context;
456  }
457 
459  llvm::BuryPointer(Context.get());
460  Context.resetWithoutRelease();
461  }
462 
463  /// setASTContext - Replace the current AST context.
464  void setASTContext(ASTContext *Value);
465 
466  /// Replace the current Sema; the compiler instance takes ownership
467  /// of S.
468  void setSema(Sema *S);
469 
470  /// }
471  /// @name ASTConsumer
472  /// {
473 
474  bool hasASTConsumer() const { return (bool)Consumer; }
475 
477  assert(Consumer && "Compiler instance has no AST consumer!");
478  return *Consumer;
479  }
480 
481  /// takeASTConsumer - Remove the current AST consumer and give ownership to
482  /// the caller.
483  std::unique_ptr<ASTConsumer> takeASTConsumer() { return std::move(Consumer); }
484 
485  /// setASTConsumer - Replace the current AST consumer; the compiler instance
486  /// takes ownership of \p Value.
487  void setASTConsumer(std::unique_ptr<ASTConsumer> Value);
488 
489  /// }
490  /// @name Semantic analysis
491  /// {
492  bool hasSema() const { return (bool)TheSema; }
493 
494  Sema &getSema() const {
495  assert(TheSema && "Compiler instance has no Sema object!");
496  return *TheSema;
497  }
498 
499  std::unique_ptr<Sema> takeSema();
500  void resetAndLeakSema();
501 
502  /// }
503  /// @name Module Management
504  /// {
505 
506  IntrusiveRefCntPtr<ASTReader> getModuleManager() const;
507  void setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader);
508 
509  std::shared_ptr<ModuleDependencyCollector> getModuleDepCollector() const;
510  void setModuleDepCollector(
511  std::shared_ptr<ModuleDependencyCollector> Collector);
512 
513  std::shared_ptr<PCHContainerOperations> getPCHContainerOperations() const {
514  return ThePCHContainerOperations;
515  }
516 
517  /// Return the appropriate PCHContainerWriter depending on the
518  /// current CodeGenOptions.
520  assert(Invocation && "cannot determine module format without invocation");
521  StringRef Format = getHeaderSearchOpts().ModuleFormat;
522  auto *Writer = ThePCHContainerOperations->getWriterOrNull(Format);
523  if (!Writer) {
524  if (Diagnostics)
525  Diagnostics->Report(diag::err_module_format_unhandled) << Format;
526  llvm::report_fatal_error("unknown module format");
527  }
528  return *Writer;
529  }
530 
531  /// Return the appropriate PCHContainerReader depending on the
532  /// current CodeGenOptions.
534  assert(Invocation && "cannot determine module format without invocation");
535  StringRef Format = getHeaderSearchOpts().ModuleFormat;
536  auto *Reader = ThePCHContainerOperations->getReaderOrNull(Format);
537  if (!Reader) {
538  if (Diagnostics)
539  Diagnostics->Report(diag::err_module_format_unhandled) << Format;
540  llvm::report_fatal_error("unknown module format");
541  }
542  return *Reader;
543  }
544 
545  /// }
546  /// @name Code Completion
547  /// {
548 
549  bool hasCodeCompletionConsumer() const { return (bool)CompletionConsumer; }
550 
552  assert(CompletionConsumer &&
553  "Compiler instance has no code completion consumer!");
554  return *CompletionConsumer;
555  }
556 
557  /// setCodeCompletionConsumer - Replace the current code completion consumer;
558  /// the compiler instance takes ownership of \p Value.
559  void setCodeCompletionConsumer(CodeCompleteConsumer *Value);
560 
561  /// }
562  /// @name Frontend timer
563  /// {
564 
565  bool hasFrontendTimer() const { return (bool)FrontendTimer; }
566 
567  llvm::Timer &getFrontendTimer() const {
568  assert(FrontendTimer && "Compiler instance has no frontend timer!");
569  return *FrontendTimer;
570  }
571 
572  /// }
573  /// @name Output Files
574  /// {
575 
576  /// addOutputFile - Add an output file onto the list of tracked output files.
577  ///
578  /// \param OutFile - The output file info.
579  void addOutputFile(OutputFile &&OutFile);
580 
581  /// clearOutputFiles - Clear the output file list. The underlying output
582  /// streams must have been closed beforehand.
583  ///
584  /// \param EraseFiles - If true, attempt to erase the files from disk.
585  void clearOutputFiles(bool EraseFiles);
586 
587  /// }
588  /// @name Construction Utility Methods
589  /// {
590 
591  /// Create the diagnostics engine using the invocation's diagnostic options
592  /// and replace any existing one with it.
593  ///
594  /// Note that this routine also replaces the diagnostic client,
595  /// allocating one if one is not provided.
596  ///
597  /// \param Client If non-NULL, a diagnostic client that will be
598  /// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
599  /// unit.
600  ///
601  /// \param ShouldOwnClient If Client is non-NULL, specifies whether
602  /// the diagnostic object should take ownership of the client.
603  void createDiagnostics(DiagnosticConsumer *Client = nullptr,
604  bool ShouldOwnClient = true);
605 
606  /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
607  ///
608  /// If no diagnostic client is provided, this creates a
609  /// DiagnosticConsumer that is owned by the returned diagnostic
610  /// object, if using directly the caller is responsible for
611  /// releasing the returned DiagnosticsEngine's client eventually.
612  ///
613  /// \param Opts - The diagnostic options; note that the created text
614  /// diagnostic object contains a reference to these options.
615  ///
616  /// \param Client If non-NULL, a diagnostic client that will be
617  /// attached to (and, then, owned by) the returned DiagnosticsEngine
618  /// object.
619  ///
620  /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
621  /// used by some diagnostics printers (for logging purposes only).
622  ///
623  /// \return The new object on success, or null on failure.
625  createDiagnostics(DiagnosticOptions *Opts,
626  DiagnosticConsumer *Client = nullptr,
627  bool ShouldOwnClient = true,
628  const CodeGenOptions *CodeGenOpts = nullptr);
629 
630  /// Create the file manager and replace any existing one with it.
631  ///
632  /// \return The new file manager on success, or null on failure.
633  FileManager *
634  createFileManager(IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr);
635 
636  /// Create the source manager and replace any existing one with it.
637  void createSourceManager(FileManager &FileMgr);
638 
639  /// Create the preprocessor, using the invocation, file, and source managers,
640  /// and replace any existing one with it.
641  void createPreprocessor(TranslationUnitKind TUKind);
642 
643  std::string getSpecificModuleCachePath();
644 
645  /// Create the AST context.
646  void createASTContext();
647 
648  /// Create an external AST source to read a PCH file and attach it to the AST
649  /// context.
650  void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation,
651  bool AllowPCHWithCompilerErrors,
652  void *DeserializationListener,
653  bool OwnDeserializationListener);
654 
655  /// Create an external AST source to read a PCH file.
656  ///
657  /// \return - The new object on success, or null on failure.
658  static IntrusiveRefCntPtr<ASTReader> createPCHExternalASTSource(
659  StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
660  bool AllowPCHWithCompilerErrors, Preprocessor &PP,
661  InMemoryModuleCache &ModuleCache, ASTContext &Context,
662  const PCHContainerReader &PCHContainerRdr,
663  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
664  DependencyFileGenerator *DependencyFile,
665  ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
666  void *DeserializationListener, bool OwnDeserializationListener,
667  bool Preamble, bool UseGlobalModuleIndex);
668 
669  /// Create a code completion consumer using the invocation; note that this
670  /// will cause the source manager to truncate the input source file at the
671  /// completion point.
672  void createCodeCompletionConsumer();
673 
674  /// Create a code completion consumer to print code completion results, at
675  /// \p Filename, \p Line, and \p Column, to the given output stream \p OS.
676  static CodeCompleteConsumer *createCodeCompletionConsumer(
677  Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column,
678  const CodeCompleteOptions &Opts, raw_ostream &OS);
679 
680  /// Create the Sema object to be used for parsing.
681  void createSema(TranslationUnitKind TUKind,
682  CodeCompleteConsumer *CompletionConsumer);
683 
684  /// Create the frontend timer and replace any existing one with it.
685  void createFrontendTimer();
686 
687  /// Create the default output file (from the invocation's options) and add it
688  /// to the list of tracked output files.
689  ///
690  /// The files created by this function always use temporary files to write to
691  /// their result (that is, the data is written to a temporary file which will
692  /// atomically replace the target output on success).
693  ///
694  /// \return - Null on error.
695  std::unique_ptr<raw_pwrite_stream>
696  createDefaultOutputFile(bool Binary = true, StringRef BaseInput = "",
697  StringRef Extension = "");
698 
699  /// Create a new output file and add it to the list of tracked output files,
700  /// optionally deriving the output path name.
701  ///
702  /// \return - Null on error.
703  std::unique_ptr<raw_pwrite_stream>
704  createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal,
705  StringRef BaseInput, StringRef Extension, bool UseTemporary,
706  bool CreateMissingDirectories = false);
707 
708  /// Create a new output file, optionally deriving the output path name.
709  ///
710  /// If \p OutputPath is empty, then createOutputFile will derive an output
711  /// path location as \p BaseInput, with any suffix removed, and \p Extension
712  /// appended. If \p OutputPath is not stdout and \p UseTemporary
713  /// is true, createOutputFile will create a new temporary file that must be
714  /// renamed to \p OutputPath in the end.
715  ///
716  /// \param OutputPath - If given, the path to the output file.
717  /// \param Error [out] - On failure, the error.
718  /// \param BaseInput - If \p OutputPath is empty, the input path name to use
719  /// for deriving the output path.
720  /// \param Extension - The extension to use for derived output names.
721  /// \param Binary - The mode to open the file in.
722  /// \param RemoveFileOnSignal - Whether the file should be registered with
723  /// llvm::sys::RemoveFileOnSignal. Note that this is not safe for
724  /// multithreaded use, as the underlying signal mechanism is not reentrant
725  /// \param UseTemporary - Create a new temporary file that must be renamed to
726  /// OutputPath in the end.
727  /// \param CreateMissingDirectories - When \p UseTemporary is true, create
728  /// missing directories in the output path.
729  /// \param ResultPathName [out] - If given, the result path name will be
730  /// stored here on success.
731  /// \param TempPathName [out] - If given, the temporary file path name
732  /// will be stored here on success.
733  std::unique_ptr<raw_pwrite_stream>
734  createOutputFile(StringRef OutputPath, std::error_code &Error, bool Binary,
735  bool RemoveFileOnSignal, StringRef BaseInput,
736  StringRef Extension, bool UseTemporary,
737  bool CreateMissingDirectories, std::string *ResultPathName,
738  std::string *TempPathName);
739 
740  std::unique_ptr<raw_pwrite_stream> createNullOutputFile();
741 
742  /// }
743  /// @name Initialization Utility Methods
744  /// {
745 
746  /// InitializeSourceManager - Initialize the source manager to set InputFile
747  /// as the main file.
748  ///
749  /// \return True on success.
750  bool InitializeSourceManager(const FrontendInputFile &Input);
751 
752  /// InitializeSourceManager - Initialize the source manager to set InputFile
753  /// as the main file.
754  ///
755  /// \return True on success.
756  static bool InitializeSourceManager(const FrontendInputFile &Input,
757  DiagnosticsEngine &Diags,
758  FileManager &FileMgr,
759  SourceManager &SourceMgr,
760  HeaderSearch *HS,
761  DependencyOutputOptions &DepOpts,
762  const FrontendOptions &Opts);
763 
764  /// }
765 
766  void setOutputStream(std::unique_ptr<llvm::raw_pwrite_stream> OutStream) {
767  OutputStream = std::move(OutStream);
768  }
769 
770  std::unique_ptr<llvm::raw_pwrite_stream> takeOutputStream() {
771  return std::move(OutputStream);
772  }
773 
774  // Create module manager.
775  void createModuleManager();
776 
777  bool loadModuleFile(StringRef FileName);
778 
779  ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path,
781  bool IsInclusionDirective) override;
782 
783  void loadModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName,
784  StringRef Source) override;
785 
786  void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility,
787  SourceLocation ImportLoc) override;
788 
790  return ModuleLoader::HadFatalFailure;
791  }
792 
793  GlobalModuleIndex *loadGlobalModuleIndex(SourceLocation TriggerLoc) override;
794 
795  bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override;
796 
797  void addDependencyCollector(std::shared_ptr<DependencyCollector> Listener) {
798  DependencyCollectors.push_back(std::move(Listener));
799  }
800 
801  void setExternalSemaSource(IntrusiveRefCntPtr<ExternalSemaSource> ESS);
802 
803  InMemoryModuleCache &getModuleCache() const { return *ModuleCache; }
804 };
805 
806 } // end namespace clang
807 
808 #endif
LangOptions & getLangOpts()
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
const TargetOptions & getTargetOpts() const
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:29
Defines the SourceManager interface.
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Abstract base class for actions which can be performed by the frontend.
DiagnosticOptions & getDiagnosticOpts()
std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const
const HeaderSearchOptions & getHeaderSearchOpts() const
InMemoryModuleCache & getModuleCache() const
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
ASTContext & getASTContext() const
const FrontendOptions & getFrontendOpts() const
Options for controlling the target.
Definition: TargetOptions.h:26
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1489
DependencyOutputOptions & getDependencyOutputOpts()
const FileSystemOptions & getFileSystemOpts() const
const DependencyOutputOptions & getDependencyOutputOpts() const
void setOutputStream(std::unique_ptr< llvm::raw_pwrite_stream > OutStream)
}
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
CodeGenOptions & getCodeGenOpts()
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
std::shared_ptr< Preprocessor > getPreprocessorPtr()
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
Describes a module or submodule.
Definition: Module.h:64
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
This abstract interface provides operations for creating containers for serialized ASTs (precompiled ...
FrontendOptions & getFrontendOpts()
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:33
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:148
ASTConsumer & getASTConsumer() const
Defines the Diagnostic-related interfaces.
HeaderSearchOptions & getHeaderSearchOpts()
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Builds a depdenency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...
Definition: Utils.h:118
AnalyzerOptionsRef getAnalyzerOpts()
CodeCompleteConsumer & getCodeCompletionConsumer() const
llvm::vfs::FileSystem & getVirtualFileSystem() const
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:158
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:35
StringRef Filename
Definition: Format.cpp:1707
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E).
Exposes information about the current target.
Definition: TargetInfo.h:161
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
const AnnotatedLine * Line
TargetInfo * getAuxTarget() const
const CodeGenOptions & getCodeGenOpts() const
An input file for the front end.
In-memory cache for modules.
FileSystemOptions & getFileSystemOpts()
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
std::unique_ptr< llvm::raw_pwrite_stream > takeOutputStream()
Options for controlling the compiler diagnostics engine.
const DiagnosticOptions & getDiagnosticOpts() const
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
const PreprocessorOptions & getPreprocessorOpts() const
A global index for a set of module files, providing information about the identifiers within those mo...
Abstract interface for a consumer of code-completion information.
Options controlling the behavior of code completion.
Dataflow Directional Tag Classes.
FileManager & getFileManager() const
Return the current file manager to the caller.
llvm::Timer & getFrontendTimer() const
Helper class for holding the data necessary to invoke the compiler.
SourceManager & getSourceManager() const
Return the current source manager.
FrontendOptions - Options for controlling the behavior of the frontend.
Abstract interface for a module loader.
Definition: ModuleLoader.h:73
TargetInfo & getTarget() const
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
const LangOptions & getLangOpts() const
Keeps track of options that affect how file operations are performed.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
bool hasCodeCompletionConsumer() const
DiagnosticConsumer & getDiagnosticClient() const
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:361
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
bool hadModuleLoaderFatalFailure() const
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:273
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
TargetOptions & getTargetOpts()
This class handles loading and caching of source files into memory.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:123