Home | History | Annotate | Download | only in Frontend 
      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>
     33 using namespace clang;
     34 
     35 template class llvm::Registry<clang::PluginASTAction>;
     36 
     37 namespace {
     38 
     39 class DelegatingDeserializationListener : public ASTDeserializationListener {
     40   ASTDeserializationListener *Previous;
     41   bool DeletePrevious;
     42 
     43 public:
     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.
     81 class DeserializedDeclsDumper : public DelegatingDeserializationListener {
     82 public:
     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.
     99 class DeserializedDeclsChecker : public DelegatingDeserializationListener {
    100   ASTContext &Ctx;
    101   std::set<std::string> NamesToCheck;
    102 
    103 public:
    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 
    127 FrontendAction::FrontendAction() : Instance(nullptr) {}
    128 
    129 FrontendAction::~FrontendAction() {}
    130 
    131 void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput,
    132                                      std::unique_ptr<ASTUnit> AST) {
    133   this->CurrentInput = CurrentInput;
    134   CurrentASTUnit = std::move(AST);
    135 }
    136 
    137 std::unique_ptr<ASTConsumer>
    138 FrontendAction::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 
    171 bool 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 
    432 bool 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 
    455 void 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 
    511 bool FrontendAction::shouldEraseOutputFiles() {
    512   return getCompilerInstance().getDiagnostics().hasErrorOccurred();
    513 }
    514 
    515 //===----------------------------------------------------------------------===//
    516 // Utility Actions
    517 //===----------------------------------------------------------------------===//
    518 
    519 void 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 
    542 void PluginASTAction::anchor() { }
    543 
    544 std::unique_ptr<ASTConsumer>
    545 PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI,
    546                                               StringRef InFile) {
    547   llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
    548 }
    549 
    550 std::unique_ptr<ASTConsumer>
    551 WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI,
    552                                          StringRef InFile) {
    553   return WrappedAction->CreateASTConsumer(CI, InFile);
    554 }
    555 bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) {
    556   return WrappedAction->BeginInvocation(CI);
    557 }
    558 bool WrapperFrontendAction::BeginSourceFileAction(CompilerInstance &CI,
    559                                                   StringRef Filename) {
    560   WrappedAction->setCurrentInput(getCurrentInput());
    561   WrappedAction->setCompilerInstance(&CI);
    562   return WrappedAction->BeginSourceFileAction(CI, Filename);
    563 }
    564 void WrapperFrontendAction::ExecuteAction() {
    565   WrappedAction->ExecuteAction();
    566 }
    567 void WrapperFrontendAction::EndSourceFileAction() {
    568   WrappedAction->EndSourceFileAction();
    569 }
    570 
    571 bool WrapperFrontendAction::usesPreprocessorOnly() const {
    572   return WrappedAction->usesPreprocessorOnly();
    573 }
    574 TranslationUnitKind WrapperFrontendAction::getTranslationUnitKind() {
    575   return WrappedAction->getTranslationUnitKind();
    576 }
    577 bool WrapperFrontendAction::hasPCHSupport() const {
    578   return WrappedAction->hasPCHSupport();
    579 }
    580 bool WrapperFrontendAction::hasASTFileSupport() const {
    581   return WrappedAction->hasASTFileSupport();
    582 }
    583 bool WrapperFrontendAction::hasIRSupport() const {
    584   return WrappedAction->hasIRSupport();
    585 }
    586 bool WrapperFrontendAction::hasCodeCompletionSupport() const {
    587   return WrappedAction->hasCodeCompletionSupport();
    588 }
    589 
    590 WrapperFrontendAction::WrapperFrontendAction(FrontendAction *WrappedAction)
    591   : WrappedAction(WrappedAction) {}
    592 
    593