Coverage Report

Created: 2020-09-15 12:33

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