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