clang 8.0.0

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"
15 #include "clang/Basic/SourceManager.h"
16 #include "clang/Frontend/CompilerInvocation.h"
17 #include "clang/Frontend/PCHContainerOperations.h"
18 #include "clang/Frontend/Utils.h"
19 #include "clang/Lex/HeaderSearchOptions.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.
73 class CompilerInstance : public ModuleLoader {
74 /// The options used in this compiler instance.
75 std::shared_ptr<CompilerInvocation> Invocation;
76
77 /// The diagnostics engine instance.
78 IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics;
79
80 /// The target being compiled for.
81 IntrusiveRefCntPtr<TargetInfo> Target;
82
83 /// Auxiliary Target info.
84 IntrusiveRefCntPtr<TargetInfo> AuxTarget;
85
86 /// The virtual file system.
87 IntrusiveRefCntPtr<llvm::vfs::FileSystem> VirtualFileSystem;
88
89 /// The file manager.
90 IntrusiveRefCntPtr<FileManager> FileMgr;
91
92 /// The source manager.
93 IntrusiveRefCntPtr<SourceManager> SourceMgr;
94
95 /// The cache of PCM files.
96 IntrusiveRefCntPtr<MemoryBufferCache> PCMCache;
97
98 /// The preprocessor.
99 std::shared_ptr<Preprocessor> PP;
100
101 /// The AST context.
102 IntrusiveRefCntPtr<ASTContext> Context;
103
104 /// An optional sema source that will be attached to sema.
105 IntrusiveRefCntPtr<ExternalSemaSource> ExternalSemaSrc;
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
240 CompilerInvocation &getInvocation() {
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
261 AnalyzerOptionsRef getAnalyzerOpts() {
262 return Invocation->getAnalyzerOpts();
263 }
264
265 CodeGenOptions &getCodeGenOpts() {
266 return Invocation->getCodeGenOpts();
267 }
268 const CodeGenOptions &getCodeGenOpts() const {
269 return Invocation->getCodeGenOpts();
270 }
271
272 DependencyOutputOptions &getDependencyOutputOpts() {
273 return Invocation->getDependencyOutputOpts();
274 }
275 const DependencyOutputOptions &getDependencyOutputOpts() const {
276 return Invocation->getDependencyOutputOpts();
277 }
278
279 DiagnosticOptions &getDiagnosticOpts() {
280 return Invocation->getDiagnosticOpts();
281 }
282 const DiagnosticOptions &getDiagnosticOpts() const {
283 return Invocation->getDiagnosticOpts();
284 }
285
286 FileSystemOptions &getFileSystemOpts() {
287 return Invocation->getFileSystemOpts();
288 }
289 const FileSystemOptions &getFileSystemOpts() const {
290 return Invocation->getFileSystemOpts();
291 }
292
293 FrontendOptions &getFrontendOpts() {
294 return Invocation->getFrontendOpts();
295 }
296 const FrontendOptions &getFrontendOpts() const {
297 return Invocation->getFrontendOpts();
298 }
299
300 HeaderSearchOptions &getHeaderSearchOpts() {
301 return Invocation->getHeaderSearchOpts();
302 }
303 const HeaderSearchOptions &getHeaderSearchOpts() const {
304 return Invocation->getHeaderSearchOpts();
305 }
306 std::shared_ptr<HeaderSearchOptions> getHeaderSearchOptsPtr() const {
307 return Invocation->getHeaderSearchOptsPtr();
308 }
309
310 LangOptions &getLangOpts() {
311 return *Invocation->getLangOpts();
312 }
313 const LangOptions &getLangOpts() const {
314 return *Invocation->getLangOpts();
315 }
316
317 PreprocessorOptions &getPreprocessorOpts() {
318 return Invocation->getPreprocessorOpts();
319 }
320 const PreprocessorOptions &getPreprocessorOpts() const {
321 return Invocation->getPreprocessorOpts();
322 }
323
324 PreprocessorOutputOptions &getPreprocessorOutputOpts() {
325 return Invocation->getPreprocessorOutputOpts();
326 }
327 const PreprocessorOutputOptions &getPreprocessorOutputOpts() const {
328 return Invocation->getPreprocessorOutputOpts();
329 }
330
331 TargetOptions &getTargetOpts() {
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.
345 DiagnosticsEngine &getDiagnostics() const {
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
353 DiagnosticConsumer &getDiagnosticClient() const {
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
365 TargetInfo &getTarget() const {
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.
398 void setVirtualFileSystem(IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS) {
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.
409 FileManager &getFileManager() const {
410 assert(FileMgr && "Compiler instance has no file manager!");
411 return *FileMgr;
412 }
413
414 void resetAndLeakFileManager() {
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.
429 SourceManager &getSourceManager() const {
430 assert(SourceMgr && "Compiler instance has no source manager!");
431 return *SourceMgr;
432 }
433
434 void resetAndLeakSourceManager() {
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.
449 Preprocessor &getPreprocessor() const {
450 assert(PP && "Compiler instance has no preprocessor!");
451 return *PP;
452 }
453
454 std::shared_ptr<Preprocessor> getPreprocessorPtr() { return PP; }
455
456 void resetAndLeakPreprocessor() {
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
469 ASTContext &getASTContext() const {
470 assert(Context && "Compiler instance has no AST context!");
471 return *Context;
472 }
473
474 void resetAndLeakASTContext() {
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
492 ASTConsumer &getASTConsumer() const {
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.
535 const PCHContainerWriter &getPCHContainerWriter() const {
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.
549 const PCHContainerReader &getPCHContainerReader() const {
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
567 CodeCompleteConsumer &getCodeCompletionConsumer() const {
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.
640 static IntrusiveRefCntPtr<DiagnosticsEngine>
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,
794 Module::NameVisibilityKind Visibility,
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
803 bool hadModuleLoaderFatalFailure() const {
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
clang::CompilerInstance::getLangOpts
LangOptions & getLangOpts()
Definition: CompilerInstance.h:310
clang::CompilerInstance::resetAndLeakFileManager
void resetAndLeakFileManager()
Definition: CompilerInstance.h:414
clang::CompilerInstance::getInvocation
CompilerInvocation & getInvocation()
Definition: CompilerInstance.h:240
clang::CompilerInstance::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts()
Definition: CompilerInstance.h:317
clang::FileManager
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:121
clang::ASTConsumer
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
clang::CompilerInstance::getTargetOpts
const TargetOptions & getTargetOpts() const
Definition: CompilerInstance.h:334
llvm
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
SourceManager.h
Defines the SourceManager interface.
PCHContainerOperations.h
clang::CompilerInstance::getPCHContainerOperations
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Definition: CompilerInstance.h:529
clang::FrontendAction
Abstract base class for actions which can be performed by the frontend.
Definition: FrontendAction.h:36
clang::CompilerInstance::getDiagnosticOpts
DiagnosticOptions & getDiagnosticOpts()
Definition: CompilerInstance.h:279
clang::CompilerInstance::getHeaderSearchOptsPtr
std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const
Definition: CompilerInstance.h:306
clang::CompilerInstance::getHeaderSearchOpts
const HeaderSearchOptions & getHeaderSearchOpts() const
Definition: CompilerInstance.h:303
clang::PreprocessorOptions
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Definition: PreprocessorOptions.h:43
clang::CompilerInstance::getASTContext
ASTContext & getASTContext() const
Definition: CompilerInstance.h:469
Value
Value
Definition: UninitializedValues.cpp:102
clang::CompilerInstance::getFrontendOpts
const FrontendOptions & getFrontendOpts() const
Definition: CompilerInstance.h:296
clang::TargetOptions
Options for controlling the target.
Definition: TargetOptions.h:27
clang::MemoryBufferCache
Manage memory buffers across multiple users.
Definition: MemoryBufferCache.h:32
clang::DiagnosticConsumer
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1488
clang::CompilerInstance::getDependencyOutputOpts
DependencyOutputOptions & getDependencyOutputOpts()
Definition: CompilerInstance.h:272
clang::CompilerInstance::getFileSystemOpts
const FileSystemOptions & getFileSystemOpts() const
Definition: CompilerInstance.h:289
clang::CompilerInstance::getDependencyOutputOpts
const DependencyOutputOptions & getDependencyOutputOpts() const
Definition: CompilerInstance.h:275
clang::MultiVersionKind::Target
clang::CompilerInstance::setOutputStream
void setOutputStream(std::unique_ptr< llvm::raw_pwrite_stream > OutStream)
}
Definition: CompilerInstance.h:780
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
clang::CompilerInstance::getCodeGenOpts
CodeGenOptions & getCodeGenOpts()
Definition: CompilerInstance.h:265
clang::CompilerInstance::getPreprocessorOutputOpts
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
Definition: CompilerInstance.h:327
clang::CompilerInstance::getPreprocessorPtr
std::shared_ptr< Preprocessor > getPreprocessorPtr()
Definition: CompilerInstance.h:454
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
clang::Module
Describes a module or submodule.
Definition: Module.h:65
clang::CompilerInstance::getPCMCache
MemoryBufferCache & getPCMCache() const
Definition: CompilerInstance.h:817
clang::CompilerInstance::getPCHContainerWriter
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
Definition: CompilerInstance.h:535
clang::CompilerInstance::setBuildGlobalModuleIndex
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
Definition: CompilerInstance.h:253
clang::PCHContainerWriter
This abstract interface provides operations for creating containers for serialized ASTs (precompiled ...
Definition: PCHContainerOperations.h:39
clang::CompilerInstance::getFrontendOpts
FrontendOptions & getFrontendOpts()
Definition: CompilerInstance.h:293
clang::Visibility
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:34
clang::CompilerInstance::getPreprocessorOutputOpts
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Definition: CompilerInstance.h:324
clang::CompilerInstance::hasFrontendTimer
bool hasFrontendTimer() const
Definition: CompilerInstance.h:581
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
clang::CompilerInstance::getASTConsumer
ASTConsumer & getASTConsumer() const
Definition: CompilerInstance.h:492
Diagnostic.h
Defines the Diagnostic-related interfaces.
Utils.h
clang::CompilerInstance::hasASTConsumer
bool hasASTConsumer() const
Definition: CompilerInstance.h:490
ModuleLoader.h
clang::CompilerInstance::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts()
Definition: CompilerInstance.h:300
clang::PCHContainerReader
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
Definition: PCHContainerOperations.h:58
llvm::ArrayRef
Definition: LLVM.h:32
clang::DependencyFileGenerator
Builds a depdenency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...
Definition: Utils.h:119
clang::CompilerInstance::getAnalyzerOpts
AnalyzerOptionsRef getAnalyzerOpts()
Definition: CompilerInstance.h:261
clang::CompilerInstance::getCodeCompletionConsumer
CodeCompleteConsumer & getCodeCompletionConsumer() const
Definition: CompilerInstance.h:567
clang::CompilerInstance::getVirtualFileSystem
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: CompilerInstance.h:388
clang::HeaderSearch
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:148
clang::CompilerInstance::getSema
Sema & getSema() const
Definition: CompilerInstance.h:510
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
clang::ModuleLoadResult
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:36
Filename
StringRef Filename
Definition: Format.cpp:1629
clang::CompilerInstance::resetAndLeakPreprocessor
void resetAndLeakPreprocessor()
Definition: CompilerInstance.h:456
clang::PreprocessorOutputOptions
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E).
Definition: PreprocessorOutputOptions.h:17
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:54
clang::CompilerInstance::addDependencyCollector
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
Definition: CompilerInstance.h:811
Line
const AnnotatedLine * Line
Definition: UsingDeclarationsSorter.cpp:69
clang::CompilerInstance::hasFileManager
bool hasFileManager() const
Definition: CompilerInstance.h:406
clang::CompilerInstance::getAuxTarget
TargetInfo * getAuxTarget() const
Definition: CompilerInstance.h:377
CompilerInvocation.h
clang::CompilerInstance::getCodeGenOpts
const CodeGenOptions & getCodeGenOpts() const
Definition: CompilerInstance.h:268
clang::FrontendInputFile
An input file for the front end.
Definition: FrontendOptions.h:199
ASTConsumer.h
clang::SkipFunctionBodiesScope::Preamble
clang::CompilerInstance::getFileSystemOpts
FileSystemOptions & getFileSystemOpts()
Definition: CompilerInstance.h:286
clang::CompilerInstance::hasPreprocessor
bool hasPreprocessor() const
Definition: CompilerInstance.h:446
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:45
clang::CompilerInstance
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Definition: CompilerInstance.h:73
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::CompilerInstance::resetAndLeakSourceManager
void resetAndLeakSourceManager()
Definition: CompilerInstance.h:434
clang::CompilerInstance::takeOutputStream
std::unique_ptr< llvm::raw_pwrite_stream > takeOutputStream()
Definition: CompilerInstance.h:784
clang::DiagnosticOptions
Options for controlling the compiler diagnostics engine.
Definition: DiagnosticOptions.h:64
clang::CompilerInstance::hasVirtualFileSystem
bool hasVirtualFileSystem() const
Definition: CompilerInstance.h:386
clang::CompilerInstance::hasSourceManager
bool hasSourceManager() const
Definition: CompilerInstance.h:426
clang::CompilerInstance::getDiagnosticOpts
const DiagnosticOptions & getDiagnosticOpts() const
Definition: CompilerInstance.h:282
clang::DependencyOutputOptions
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
Definition: DependencyOutputOptions.h:26
clang::CompilerInstance::getPreprocessorOpts
const PreprocessorOptions & getPreprocessorOpts() const
Definition: CompilerInstance.h:320
clang::GlobalModuleIndex
A global index for a set of module files, providing information about the identifiers within those mo...
Definition: GlobalModuleIndex.h:56
clang::CodeCompleteConsumer
Abstract interface for a consumer of code-completion information.
Definition: CodeCompleteConsumer.h:999
clang::CodeCompleteOptions
Options controlling the behavior of code completion.
Definition: CodeCompleteOptions.h:16
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::CompilerInstance::getFileManager
FileManager & getFileManager() const
Return the current file manager to the caller.
Definition: CompilerInstance.h:409
clang::CompilerInstance::getFrontendTimer
llvm::Timer & getFrontendTimer() const
Definition: CompilerInstance.h:583
clang::CompilerInstance::hasInvocation
bool hasInvocation() const
Definition: CompilerInstance.h:238
clang::index::SymbolKind::Module
clang::CompilerInvocation
Helper class for holding the data necessary to invoke the compiler.
Definition: CompilerInvocation.h:121
clang::CompilerInstance::getSourceManager
SourceManager & getSourceManager() const
Return the current source manager.
Definition: CompilerInstance.h:429
clang::FrontendOptions
FrontendOptions - Options for controlling the behavior of the frontend.
Definition: FrontendOptions.h:242
clang::ModuleLoader
Abstract interface for a module loader.
Definition: ModuleLoader.h:74
clang::CompilerInstance::hasDiagnostics
bool hasDiagnostics() const
Definition: CompilerInstance.h:342
clang::CompilerInstance::getTarget
TargetInfo & getTarget() const
Definition: CompilerInstance.h:365
clang::CodeGenOptions
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
Definition: CodeGenOptions.h:46
clang::CompilerInstance::getLangOpts
const LangOptions & getLangOpts() const
Definition: CompilerInstance.h:313
clang::CompilerInstance::hasTarget
bool hasTarget() const
Definition: CompilerInstance.h:363
clang::CompilerInstance::setVirtualFileSystem
void setVirtualFileSystem(IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)
Replace the current virtual file system.
Definition: CompilerInstance.h:398
clang::CompilerInstance::hasASTContext
bool hasASTContext() const
Definition: CompilerInstance.h:467
HeaderSearchOptions.h
clang::FileSystemOptions
Keeps track of options that affect how file operations are performed.
Definition: FileSystemOptions.h:23
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:449
clang::CompilerInstance::hasCodeCompletionConsumer
bool hasCodeCompletionConsumer() const
Definition: CompilerInstance.h:565
clang::CompilerInstance::getDiagnosticClient
DiagnosticConsumer & getDiagnosticClient() const
Definition: CompilerInstance.h:353
clang::CompilerInstance::resetAndLeakASTContext
void resetAndLeakASTContext()
Definition: CompilerInstance.h:474
clang::TranslationUnitKind
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:362
clang::CompilerInstance::getPCHContainerReader
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
Definition: CompilerInstance.h:549
clang::CompilerInstance::hadModuleLoaderFatalFailure
bool hadModuleLoaderFatalFailure() const
Definition: CompilerInstance.h:803
clang::Module::NameVisibilityKind
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:267
clang::CompilerInstance::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
Definition: CompilerInstance.h:345
clang::HeaderSearchOptions
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
Definition: HeaderSearchOptions.h:67
clang::CompilerInstance::takeASTConsumer
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
Definition: CompilerInstance.h:499
clang::CompilerInstance::getTargetOpts
TargetOptions & getTargetOpts()
Definition: CompilerInstance.h:331
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:582
clang::CompilerInstance::hasSema
bool hasSema() const
Definition: CompilerInstance.h:508
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125