1//===--- FrontendAction.cpp -----------------------------------------------===//
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#include "clang/Frontend/FrontendAction.h"
11#include "clang/AST/ASTConsumer.h"
12#include "clang/AST/ASTContext.h"
13#include "clang/AST/DeclGroup.h"
14#include "clang/Frontend/ASTUnit.h"
15#include "clang/Frontend/CompilerInstance.h"
16#include "clang/Frontend/FrontendDiagnostic.h"
17#include "clang/Frontend/FrontendPluginRegistry.h"
18#include "clang/Frontend/LayoutOverrideSource.h"
19#include "clang/Frontend/MultiplexConsumer.h"
20#include "clang/Frontend/Utils.h"
21#include "clang/Lex/HeaderSearch.h"
22#include "clang/Lex/Preprocessor.h"
23#include "clang/Parse/ParseAST.h"
24#include "clang/Serialization/ASTDeserializationListener.h"
25#include "clang/Serialization/ASTReader.h"
26#include "clang/Serialization/GlobalModuleIndex.h"
27#include "llvm/Support/ErrorHandling.h"
28#include "llvm/Support/FileSystem.h"
29#include "llvm/Support/MemoryBuffer.h"
30#include "llvm/Support/Timer.h"
31#include "llvm/Support/raw_ostream.h"
32#include <system_error>
33using namespace clang;
34
35template class llvm::Registry<clang::PluginASTAction>;
36
37namespace {
38
39class DelegatingDeserializationListener : public ASTDeserializationListener {
40  ASTDeserializationListener *Previous;
41  bool DeletePrevious;
42
43public:
44  explicit DelegatingDeserializationListener(
45      ASTDeserializationListener *Previous, bool DeletePrevious)
46      : Previous(Previous), DeletePrevious(DeletePrevious) {}
47  ~DelegatingDeserializationListener() override {
48    if (DeletePrevious)
49      delete Previous;
50  }
51
52  void ReaderInitialized(ASTReader *Reader) override {
53    if (Previous)
54      Previous->ReaderInitialized(Reader);
55  }
56  void IdentifierRead(serialization::IdentID ID,
57                      IdentifierInfo *II) override {
58    if (Previous)
59      Previous->IdentifierRead(ID, II);
60  }
61  void TypeRead(serialization::TypeIdx Idx, QualType T) override {
62    if (Previous)
63      Previous->TypeRead(Idx, T);
64  }
65  void DeclRead(serialization::DeclID ID, const Decl *D) override {
66    if (Previous)
67      Previous->DeclRead(ID, D);
68  }
69  void SelectorRead(serialization::SelectorID ID, Selector Sel) override {
70    if (Previous)
71      Previous->SelectorRead(ID, Sel);
72  }
73  void MacroDefinitionRead(serialization::PreprocessedEntityID PPID,
74                           MacroDefinitionRecord *MD) override {
75    if (Previous)
76      Previous->MacroDefinitionRead(PPID, MD);
77  }
78};
79
80/// \brief Dumps deserialized declarations.
81class DeserializedDeclsDumper : public DelegatingDeserializationListener {
82public:
83  explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous,
84                                   bool DeletePrevious)
85      : DelegatingDeserializationListener(Previous, DeletePrevious) {}
86
87  void DeclRead(serialization::DeclID ID, const Decl *D) override {
88    llvm::outs() << "PCH DECL: " << D->getDeclKindName();
89    if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
90      llvm::outs() << " - " << *ND;
91    llvm::outs() << "\n";
92
93    DelegatingDeserializationListener::DeclRead(ID, D);
94  }
95};
96
97/// \brief Checks deserialized declarations and emits error if a name
98/// matches one given in command-line using -error-on-deserialized-decl.
99class DeserializedDeclsChecker : public DelegatingDeserializationListener {
100  ASTContext &Ctx;
101  std::set<std::string> NamesToCheck;
102
103public:
104  DeserializedDeclsChecker(ASTContext &Ctx,
105                           const std::set<std::string> &NamesToCheck,
106                           ASTDeserializationListener *Previous,
107                           bool DeletePrevious)
108      : DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx),
109        NamesToCheck(NamesToCheck) {}
110
111  void DeclRead(serialization::DeclID ID, const Decl *D) override {
112    if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
113      if (NamesToCheck.find(ND->getNameAsString()) != NamesToCheck.end()) {
114        unsigned DiagID
115          = Ctx.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error,
116                                                 "%0 was deserialized");
117        Ctx.getDiagnostics().Report(Ctx.getFullLoc(D->getLocation()), DiagID)
118            << ND->getNameAsString();
119      }
120
121    DelegatingDeserializationListener::DeclRead(ID, D);
122  }
123};
124
125} // end anonymous namespace
126
127FrontendAction::FrontendAction() : Instance(nullptr) {}
128
129FrontendAction::~FrontendAction() {}
130
131void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput,
132                                     std::unique_ptr<ASTUnit> AST) {
133  this->CurrentInput = CurrentInput;
134  CurrentASTUnit = std::move(AST);
135}
136
137std::unique_ptr<ASTConsumer>
138FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
139                                         StringRef InFile) {
140  std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
141  if (!Consumer)
142    return nullptr;
143
144  if (CI.getFrontendOpts().AddPluginActions.size() == 0)
145    return Consumer;
146
147  // Make sure the non-plugin consumer is first, so that plugins can't
148  // modifiy the AST.
149  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
150  Consumers.push_back(std::move(Consumer));
151
152  for (size_t i = 0, e = CI.getFrontendOpts().AddPluginActions.size();
153       i != e; ++i) {
154    // This is O(|plugins| * |add_plugins|), but since both numbers are
155    // way below 50 in practice, that's ok.
156    for (FrontendPluginRegistry::iterator
157        it = FrontendPluginRegistry::begin(),
158        ie = FrontendPluginRegistry::end();
159        it != ie; ++it) {
160      if (it->getName() != CI.getFrontendOpts().AddPluginActions[i])
161        continue;
162      std::unique_ptr<PluginASTAction> P = it->instantiate();
163      if (P->ParseArgs(CI, CI.getFrontendOpts().AddPluginArgs[i]))
164        Consumers.push_back(P->CreateASTConsumer(CI, InFile));
165    }
166  }
167
168  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
169}
170
171bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
172                                     const FrontendInputFile &Input) {
173  assert(!Instance && "Already processing a source file!");
174  assert(!Input.isEmpty() && "Unexpected empty filename!");
175  setCurrentInput(Input);
176  setCompilerInstance(&CI);
177
178  StringRef InputFile = Input.getFile();
179  bool HasBegunSourceFile = false;
180  if (!BeginInvocation(CI))
181    goto failure;
182
183  // AST files follow a very different path, since they share objects via the
184  // AST unit.
185  if (Input.getKind() == IK_AST) {
186    assert(!usesPreprocessorOnly() &&
187           "Attempt to pass AST file to preprocessor only action!");
188    assert(hasASTFileSupport() &&
189           "This action does not have AST file support!");
190
191    IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics());
192
193    std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
194        InputFile, CI.getPCHContainerReader(), Diags, CI.getFileSystemOpts(),
195        CI.getCodeGenOpts().DebugTypeExtRefs);
196
197    if (!AST)
198      goto failure;
199
200    // Inform the diagnostic client we are processing a source file.
201    CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
202    HasBegunSourceFile = true;
203
204    // Set the shared objects, these are reset when we finish processing the
205    // file, otherwise the CompilerInstance will happily destroy them.
206    CI.setFileManager(&AST->getFileManager());
207    CI.setSourceManager(&AST->getSourceManager());
208    CI.setPreprocessor(&AST->getPreprocessor());
209    CI.setASTContext(&AST->getASTContext());
210
211    setCurrentInput(Input, std::move(AST));
212
213    // Initialize the action.
214    if (!BeginSourceFileAction(CI, InputFile))
215      goto failure;
216
217    // Create the AST consumer.
218    CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
219    if (!CI.hasASTConsumer())
220      goto failure;
221
222    return true;
223  }
224
225  if (!CI.hasVirtualFileSystem()) {
226    if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
227          createVFSFromCompilerInvocation(CI.getInvocation(),
228                                          CI.getDiagnostics()))
229      CI.setVirtualFileSystem(VFS);
230    else
231      goto failure;
232  }
233
234  // Set up the file and source managers, if needed.
235  if (!CI.hasFileManager())
236    CI.createFileManager();
237  if (!CI.hasSourceManager())
238    CI.createSourceManager(CI.getFileManager());
239
240  // IR files bypass the rest of initialization.
241  if (Input.getKind() == IK_LLVM_IR) {
242    assert(hasIRSupport() &&
243           "This action does not have IR file support!");
244
245    // Inform the diagnostic client we are processing a source file.
246    CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
247    HasBegunSourceFile = true;
248
249    // Initialize the action.
250    if (!BeginSourceFileAction(CI, InputFile))
251      goto failure;
252
253    // Initialize the main file entry.
254    if (!CI.InitializeSourceManager(CurrentInput))
255      goto failure;
256
257    return true;
258  }
259
260  // If the implicit PCH include is actually a directory, rather than
261  // a single file, search for a suitable PCH file in that directory.
262  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
263    FileManager &FileMgr = CI.getFileManager();
264    PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
265    StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
266    std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
267    if (const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude)) {
268      std::error_code EC;
269      SmallString<128> DirNative;
270      llvm::sys::path::native(PCHDir->getName(), DirNative);
271      bool Found = false;
272      for (llvm::sys::fs::directory_iterator Dir(DirNative, EC), DirEnd;
273           Dir != DirEnd && !EC; Dir.increment(EC)) {
274        // Check whether this is an acceptable AST file.
275        if (ASTReader::isAcceptableASTFile(
276                Dir->path(), FileMgr, CI.getPCHContainerReader(),
277                CI.getLangOpts(), CI.getTargetOpts(), CI.getPreprocessorOpts(),
278                SpecificModuleCachePath)) {
279          PPOpts.ImplicitPCHInclude = Dir->path();
280          Found = true;
281          break;
282        }
283      }
284
285      if (!Found) {
286        CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
287        goto failure;
288      }
289    }
290  }
291
292  // Set up the preprocessor if needed. When parsing model files the
293  // preprocessor of the original source is reused.
294  if (!isModelParsingAction())
295    CI.createPreprocessor(getTranslationUnitKind());
296
297  // Inform the diagnostic client we are processing a source file.
298  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(),
299                                           &CI.getPreprocessor());
300  HasBegunSourceFile = true;
301
302  // Initialize the action.
303  if (!BeginSourceFileAction(CI, InputFile))
304    goto failure;
305
306  // Initialize the main file entry. It is important that this occurs after
307  // BeginSourceFileAction, which may change CurrentInput during module builds.
308  if (!CI.InitializeSourceManager(CurrentInput))
309    goto failure;
310
311  // Create the AST context and consumer unless this is a preprocessor only
312  // action.
313  if (!usesPreprocessorOnly()) {
314    // Parsing a model file should reuse the existing ASTContext.
315    if (!isModelParsingAction())
316      CI.createASTContext();
317
318    std::unique_ptr<ASTConsumer> Consumer =
319        CreateWrappedASTConsumer(CI, InputFile);
320    if (!Consumer)
321      goto failure;
322
323    // FIXME: should not overwrite ASTMutationListener when parsing model files?
324    if (!isModelParsingAction())
325      CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
326
327    if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
328      // Convert headers to PCH and chain them.
329      IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
330      source = createChainedIncludesSource(CI, FinalReader);
331      if (!source)
332        goto failure;
333      CI.setModuleManager(static_cast<ASTReader *>(FinalReader.get()));
334      CI.getASTContext().setExternalSource(source);
335    } else if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
336      // Use PCH.
337      assert(hasPCHSupport() && "This action does not have PCH support!");
338      ASTDeserializationListener *DeserialListener =
339          Consumer->GetASTDeserializationListener();
340      bool DeleteDeserialListener = false;
341      if (CI.getPreprocessorOpts().DumpDeserializedPCHDecls) {
342        DeserialListener = new DeserializedDeclsDumper(DeserialListener,
343                                                       DeleteDeserialListener);
344        DeleteDeserialListener = true;
345      }
346      if (!CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn.empty()) {
347        DeserialListener = new DeserializedDeclsChecker(
348            CI.getASTContext(),
349            CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn,
350            DeserialListener, DeleteDeserialListener);
351        DeleteDeserialListener = true;
352      }
353      CI.createPCHExternalASTSource(
354          CI.getPreprocessorOpts().ImplicitPCHInclude,
355          CI.getPreprocessorOpts().DisablePCHValidation,
356          CI.getPreprocessorOpts().AllowPCHWithCompilerErrors, DeserialListener,
357          DeleteDeserialListener);
358      if (!CI.getASTContext().getExternalSource())
359        goto failure;
360    }
361
362    CI.setASTConsumer(std::move(Consumer));
363    if (!CI.hasASTConsumer())
364      goto failure;
365  }
366
367  // Initialize built-in info as long as we aren't using an external AST
368  // source.
369  if (!CI.hasASTContext() || !CI.getASTContext().getExternalSource()) {
370    Preprocessor &PP = CI.getPreprocessor();
371
372    // If modules are enabled, create the module manager before creating
373    // any builtins, so that all declarations know that they might be
374    // extended by an external source.
375    if (CI.getLangOpts().Modules)
376      CI.createModuleManager();
377
378    PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(),
379                                           PP.getLangOpts());
380  } else {
381    // FIXME: If this is a problem, recover from it by creating a multiplex
382    // source.
383    assert((!CI.getLangOpts().Modules || CI.getModuleManager()) &&
384           "modules enabled but created an external source that "
385           "doesn't support modules");
386  }
387
388  // If we were asked to load any module map files, do so now.
389  for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) {
390    if (auto *File = CI.getFileManager().getFile(Filename))
391      CI.getPreprocessor().getHeaderSearchInfo().loadModuleMapFile(
392          File, /*IsSystem*/false);
393    else
394      CI.getDiagnostics().Report(diag::err_module_map_not_found) << Filename;
395  }
396
397  // If we were asked to load any module files, do so now.
398  for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
399    if (!CI.loadModuleFile(ModuleFile))
400      goto failure;
401
402  // If there is a layout overrides file, attach an external AST source that
403  // provides the layouts from that file.
404  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
405      CI.hasASTContext() && !CI.getASTContext().getExternalSource()) {
406    IntrusiveRefCntPtr<ExternalASTSource>
407      Override(new LayoutOverrideSource(
408                     CI.getFrontendOpts().OverrideRecordLayoutsFile));
409    CI.getASTContext().setExternalSource(Override);
410  }
411
412  return true;
413
414  // If we failed, reset state since the client will not end up calling the
415  // matching EndSourceFile().
416  failure:
417  if (isCurrentFileAST()) {
418    CI.setASTContext(nullptr);
419    CI.setPreprocessor(nullptr);
420    CI.setSourceManager(nullptr);
421    CI.setFileManager(nullptr);
422  }
423
424  if (HasBegunSourceFile)
425    CI.getDiagnosticClient().EndSourceFile();
426  CI.clearOutputFiles(/*EraseFiles=*/true);
427  setCurrentInput(FrontendInputFile());
428  setCompilerInstance(nullptr);
429  return false;
430}
431
432bool FrontendAction::Execute() {
433  CompilerInstance &CI = getCompilerInstance();
434
435  if (CI.hasFrontendTimer()) {
436    llvm::TimeRegion Timer(CI.getFrontendTimer());
437    ExecuteAction();
438  }
439  else ExecuteAction();
440
441  // If we are supposed to rebuild the global module index, do so now unless
442  // there were any module-build failures.
443  if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
444      CI.hasPreprocessor()) {
445    StringRef Cache =
446        CI.getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
447    if (!Cache.empty())
448      GlobalModuleIndex::writeIndex(CI.getFileManager(),
449                                    CI.getPCHContainerReader(), Cache);
450  }
451
452  return true;
453}
454
455void FrontendAction::EndSourceFile() {
456  CompilerInstance &CI = getCompilerInstance();
457
458  // Inform the diagnostic client we are done with this source file.
459  CI.getDiagnosticClient().EndSourceFile();
460
461  // Inform the preprocessor we are done.
462  if (CI.hasPreprocessor())
463    CI.getPreprocessor().EndSourceFile();
464
465  // Finalize the action.
466  EndSourceFileAction();
467
468  // Sema references the ast consumer, so reset sema first.
469  //
470  // FIXME: There is more per-file stuff we could just drop here?
471  bool DisableFree = CI.getFrontendOpts().DisableFree;
472  if (DisableFree) {
473    CI.resetAndLeakSema();
474    CI.resetAndLeakASTContext();
475    BuryPointer(CI.takeASTConsumer().get());
476  } else {
477    CI.setSema(nullptr);
478    CI.setASTContext(nullptr);
479    CI.setASTConsumer(nullptr);
480  }
481
482  if (CI.getFrontendOpts().ShowStats) {
483    llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFile() << "':\n";
484    CI.getPreprocessor().PrintStats();
485    CI.getPreprocessor().getIdentifierTable().PrintStats();
486    CI.getPreprocessor().getHeaderSearchInfo().PrintStats();
487    CI.getSourceManager().PrintStats();
488    llvm::errs() << "\n";
489  }
490
491  // Cleanup the output streams, and erase the output files if instructed by the
492  // FrontendAction.
493  CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
494
495  if (isCurrentFileAST()) {
496    if (DisableFree) {
497      CI.resetAndLeakPreprocessor();
498      CI.resetAndLeakSourceManager();
499      CI.resetAndLeakFileManager();
500    } else {
501      CI.setPreprocessor(nullptr);
502      CI.setSourceManager(nullptr);
503      CI.setFileManager(nullptr);
504    }
505  }
506
507  setCompilerInstance(nullptr);
508  setCurrentInput(FrontendInputFile());
509}
510
511bool FrontendAction::shouldEraseOutputFiles() {
512  return getCompilerInstance().getDiagnostics().hasErrorOccurred();
513}
514
515//===----------------------------------------------------------------------===//
516// Utility Actions
517//===----------------------------------------------------------------------===//
518
519void ASTFrontendAction::ExecuteAction() {
520  CompilerInstance &CI = getCompilerInstance();
521  if (!CI.hasPreprocessor())
522    return;
523
524  // FIXME: Move the truncation aspect of this into Sema, we delayed this till
525  // here so the source manager would be initialized.
526  if (hasCodeCompletionSupport() &&
527      !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
528    CI.createCodeCompletionConsumer();
529
530  // Use a code completion consumer?
531  CodeCompleteConsumer *CompletionConsumer = nullptr;
532  if (CI.hasCodeCompletionConsumer())
533    CompletionConsumer = &CI.getCodeCompletionConsumer();
534
535  if (!CI.hasSema())
536    CI.createSema(getTranslationUnitKind(), CompletionConsumer);
537
538  ParseAST(CI.getSema(), CI.getFrontendOpts().ShowStats,
539           CI.getFrontendOpts().SkipFunctionBodies);
540}
541
542void PluginASTAction::anchor() { }
543
544std::unique_ptr<ASTConsumer>
545PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI,
546                                              StringRef InFile) {
547  llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
548}
549
550std::unique_ptr<ASTConsumer>
551WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI,
552                                         StringRef InFile) {
553  return WrappedAction->CreateASTConsumer(CI, InFile);
554}
555bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) {
556  return WrappedAction->BeginInvocation(CI);
557}
558bool WrapperFrontendAction::BeginSourceFileAction(CompilerInstance &CI,
559                                                  StringRef Filename) {
560  WrappedAction->setCurrentInput(getCurrentInput());
561  WrappedAction->setCompilerInstance(&CI);
562  return WrappedAction->BeginSourceFileAction(CI, Filename);
563}
564void WrapperFrontendAction::ExecuteAction() {
565  WrappedAction->ExecuteAction();
566}
567void WrapperFrontendAction::EndSourceFileAction() {
568  WrappedAction->EndSourceFileAction();
569}
570
571bool WrapperFrontendAction::usesPreprocessorOnly() const {
572  return WrappedAction->usesPreprocessorOnly();
573}
574TranslationUnitKind WrapperFrontendAction::getTranslationUnitKind() {
575  return WrappedAction->getTranslationUnitKind();
576}
577bool WrapperFrontendAction::hasPCHSupport() const {
578  return WrappedAction->hasPCHSupport();
579}
580bool WrapperFrontendAction::hasASTFileSupport() const {
581  return WrappedAction->hasASTFileSupport();
582}
583bool WrapperFrontendAction::hasIRSupport() const {
584  return WrappedAction->hasIRSupport();
585}
586bool WrapperFrontendAction::hasCodeCompletionSupport() const {
587  return WrappedAction->hasCodeCompletionSupport();
588}
589
590WrapperFrontendAction::WrapperFrontendAction(FrontendAction *WrappedAction)
591  : WrappedAction(WrappedAction) {}
592
593