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