1 //===--- ExecuteCompilerInvocation.cpp ------------------------------------===// 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 // This file holds ExecuteCompilerInvocation(). It is split into its own file to 10 // minimize the impact of pulling in essentially everything else in Clang. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/ARCMigrate/ARCMTActions.h" 15 #include "clang/CodeGen/CodeGenAction.h" 16 #include "clang/Config/config.h" 17 #include "clang/Driver/Options.h" 18 #include "clang/ExtractAPI/FrontendActions.h" 19 #include "clang/Frontend/CompilerInstance.h" 20 #include "clang/Frontend/CompilerInvocation.h" 21 #include "clang/Frontend/FrontendActions.h" 22 #include "clang/Frontend/FrontendDiagnostic.h" 23 #include "clang/Frontend/FrontendPluginRegistry.h" 24 #include "clang/Frontend/Utils.h" 25 #include "clang/FrontendTool/Utils.h" 26 #include "clang/Rewrite/Frontend/FrontendActions.h" 27 #include "clang/StaticAnalyzer/Frontend/AnalyzerHelpFlags.h" 28 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h" 29 #include "llvm/Option/OptTable.h" 30 #include "llvm/Option/Option.h" 31 #include "llvm/Support/BuryPointer.h" 32 #include "llvm/Support/DynamicLibrary.h" 33 #include "llvm/Support/ErrorHandling.h" 34 using namespace clang; 35 using namespace llvm::opt; 36 37 namespace clang { 38 39 static std::unique_ptr<FrontendAction> 40 CreateFrontendBaseAction(CompilerInstance &CI) { 41 using namespace clang::frontend; 42 StringRef Action("unknown"); 43 (void)Action; 44 45 switch (CI.getFrontendOpts().ProgramAction) { 46 case ASTDeclList: return std::make_unique<ASTDeclListAction>(); 47 case ASTDump: return std::make_unique<ASTDumpAction>(); 48 case ASTPrint: return std::make_unique<ASTPrintAction>(); 49 case ASTView: return std::make_unique<ASTViewAction>(); 50 case DumpCompilerOptions: 51 return std::make_unique<DumpCompilerOptionsAction>(); 52 case DumpRawTokens: return std::make_unique<DumpRawTokensAction>(); 53 case DumpTokens: return std::make_unique<DumpTokensAction>(); 54 case EmitAssembly: return std::make_unique<EmitAssemblyAction>(); 55 case EmitBC: return std::make_unique<EmitBCAction>(); 56 case EmitHTML: return std::make_unique<HTMLPrintAction>(); 57 case EmitLLVM: return std::make_unique<EmitLLVMAction>(); 58 case EmitLLVMOnly: return std::make_unique<EmitLLVMOnlyAction>(); 59 case EmitCodeGenOnly: return std::make_unique<EmitCodeGenOnlyAction>(); 60 case EmitObj: return std::make_unique<EmitObjAction>(); 61 case ExtractAPI: 62 return std::make_unique<ExtractAPIAction>(); 63 case FixIt: return std::make_unique<FixItAction>(); 64 case GenerateModule: 65 return std::make_unique<GenerateModuleFromModuleMapAction>(); 66 case GenerateModuleInterface: 67 return std::make_unique<GenerateModuleInterfaceAction>(); 68 case GenerateHeaderModule: 69 return std::make_unique<GenerateHeaderModuleAction>(); 70 case GenerateHeaderUnit: 71 return std::make_unique<GenerateHeaderUnitAction>(); 72 case GeneratePCH: return std::make_unique<GeneratePCHAction>(); 73 case GenerateInterfaceStubs: 74 return std::make_unique<GenerateInterfaceStubsAction>(); 75 case InitOnly: return std::make_unique<InitOnlyAction>(); 76 case ParseSyntaxOnly: return std::make_unique<SyntaxOnlyAction>(); 77 case ModuleFileInfo: return std::make_unique<DumpModuleInfoAction>(); 78 case VerifyPCH: return std::make_unique<VerifyPCHAction>(); 79 case TemplightDump: return std::make_unique<TemplightDumpAction>(); 80 81 case PluginAction: { 82 for (const FrontendPluginRegistry::entry &Plugin : 83 FrontendPluginRegistry::entries()) { 84 if (Plugin.getName() == CI.getFrontendOpts().ActionName) { 85 std::unique_ptr<PluginASTAction> P(Plugin.instantiate()); 86 if ((P->getActionType() != PluginASTAction::ReplaceAction && 87 P->getActionType() != PluginASTAction::CmdlineAfterMainAction) || 88 !P->ParseArgs( 89 CI, 90 CI.getFrontendOpts().PluginArgs[std::string(Plugin.getName())])) 91 return nullptr; 92 return std::move(P); 93 } 94 } 95 96 CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name) 97 << CI.getFrontendOpts().ActionName; 98 return nullptr; 99 } 100 101 case PrintPreamble: return std::make_unique<PrintPreambleAction>(); 102 case PrintPreprocessedInput: { 103 if (CI.getPreprocessorOutputOpts().RewriteIncludes || 104 CI.getPreprocessorOutputOpts().RewriteImports) 105 return std::make_unique<RewriteIncludesAction>(); 106 return std::make_unique<PrintPreprocessedAction>(); 107 } 108 109 case RewriteMacros: return std::make_unique<RewriteMacrosAction>(); 110 case RewriteTest: return std::make_unique<RewriteTestAction>(); 111 #if CLANG_ENABLE_OBJC_REWRITER 112 case RewriteObjC: return std::make_unique<RewriteObjCAction>(); 113 #else 114 case RewriteObjC: Action = "RewriteObjC"; break; 115 #endif 116 #if CLANG_ENABLE_ARCMT 117 case MigrateSource: 118 return std::make_unique<arcmt::MigrateSourceAction>(); 119 #else 120 case MigrateSource: Action = "MigrateSource"; break; 121 #endif 122 #if CLANG_ENABLE_STATIC_ANALYZER 123 case RunAnalysis: return std::make_unique<ento::AnalysisAction>(); 124 #else 125 case RunAnalysis: Action = "RunAnalysis"; break; 126 #endif 127 case RunPreprocessorOnly: return std::make_unique<PreprocessOnlyAction>(); 128 case PrintDependencyDirectivesSourceMinimizerOutput: 129 return std::make_unique<PrintDependencyDirectivesSourceMinimizerAction>(); 130 } 131 132 #if !CLANG_ENABLE_ARCMT || !CLANG_ENABLE_STATIC_ANALYZER \ 133 || !CLANG_ENABLE_OBJC_REWRITER 134 CI.getDiagnostics().Report(diag::err_fe_action_not_available) << Action; 135 return 0; 136 #else 137 llvm_unreachable("Invalid program action!"); 138 #endif 139 } 140 141 std::unique_ptr<FrontendAction> 142 CreateFrontendAction(CompilerInstance &CI) { 143 // Create the underlying action. 144 std::unique_ptr<FrontendAction> Act = CreateFrontendBaseAction(CI); 145 if (!Act) 146 return nullptr; 147 148 const FrontendOptions &FEOpts = CI.getFrontendOpts(); 149 150 if (FEOpts.FixAndRecompile) { 151 Act = std::make_unique<FixItRecompile>(std::move(Act)); 152 } 153 154 #if CLANG_ENABLE_ARCMT 155 if (CI.getFrontendOpts().ProgramAction != frontend::MigrateSource && 156 CI.getFrontendOpts().ProgramAction != frontend::GeneratePCH) { 157 // Potentially wrap the base FE action in an ARC Migrate Tool action. 158 switch (FEOpts.ARCMTAction) { 159 case FrontendOptions::ARCMT_None: 160 break; 161 case FrontendOptions::ARCMT_Check: 162 Act = std::make_unique<arcmt::CheckAction>(std::move(Act)); 163 break; 164 case FrontendOptions::ARCMT_Modify: 165 Act = std::make_unique<arcmt::ModifyAction>(std::move(Act)); 166 break; 167 case FrontendOptions::ARCMT_Migrate: 168 Act = std::make_unique<arcmt::MigrateAction>(std::move(Act), 169 FEOpts.MTMigrateDir, 170 FEOpts.ARCMTMigrateReportOut, 171 FEOpts.ARCMTMigrateEmitARCErrors); 172 break; 173 } 174 175 if (FEOpts.ObjCMTAction != FrontendOptions::ObjCMT_None) { 176 Act = std::make_unique<arcmt::ObjCMigrateAction>(std::move(Act), 177 FEOpts.MTMigrateDir, 178 FEOpts.ObjCMTAction); 179 } 180 } 181 #endif 182 183 // If there are any AST files to merge, create a frontend action 184 // adaptor to perform the merge. 185 if (!FEOpts.ASTMergeFiles.empty()) 186 Act = std::make_unique<ASTMergeAction>(std::move(Act), 187 FEOpts.ASTMergeFiles); 188 189 return Act; 190 } 191 192 bool ExecuteCompilerInvocation(CompilerInstance *Clang) { 193 // Honor -help. 194 if (Clang->getFrontendOpts().ShowHelp) { 195 driver::getDriverOptTable().printHelp( 196 llvm::outs(), "clang -cc1 [options] file...", 197 "LLVM 'Clang' Compiler: http://clang.llvm.org", 198 /*Include=*/driver::options::CC1Option, 199 /*Exclude=*/0, /*ShowAllAliases=*/false); 200 return true; 201 } 202 203 // Honor -version. 204 // 205 // FIXME: Use a better -version message? 206 if (Clang->getFrontendOpts().ShowVersion) { 207 llvm::cl::PrintVersionMessage(); 208 return true; 209 } 210 211 Clang->LoadRequestedPlugins(); 212 213 // Honor -mllvm. 214 // 215 // FIXME: Remove this, one day. 216 // This should happen AFTER plugins have been loaded! 217 if (!Clang->getFrontendOpts().LLVMArgs.empty()) { 218 unsigned NumArgs = Clang->getFrontendOpts().LLVMArgs.size(); 219 auto Args = std::make_unique<const char*[]>(NumArgs + 2); 220 Args[0] = "clang (LLVM option parsing)"; 221 for (unsigned i = 0; i != NumArgs; ++i) 222 Args[i + 1] = Clang->getFrontendOpts().LLVMArgs[i].c_str(); 223 Args[NumArgs + 1] = nullptr; 224 llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args.get()); 225 } 226 227 #if CLANG_ENABLE_STATIC_ANALYZER 228 // These should happen AFTER plugins have been loaded! 229 230 AnalyzerOptions &AnOpts = *Clang->getAnalyzerOpts(); 231 232 // Honor -analyzer-checker-help and -analyzer-checker-help-hidden. 233 if (AnOpts.ShowCheckerHelp || AnOpts.ShowCheckerHelpAlpha || 234 AnOpts.ShowCheckerHelpDeveloper) { 235 ento::printCheckerHelp(llvm::outs(), *Clang); 236 return true; 237 } 238 239 // Honor -analyzer-checker-option-help. 240 if (AnOpts.ShowCheckerOptionList || AnOpts.ShowCheckerOptionAlphaList || 241 AnOpts.ShowCheckerOptionDeveloperList) { 242 ento::printCheckerConfigList(llvm::outs(), *Clang); 243 return true; 244 } 245 246 // Honor -analyzer-list-enabled-checkers. 247 if (AnOpts.ShowEnabledCheckerList) { 248 ento::printEnabledCheckerList(llvm::outs(), *Clang); 249 return true; 250 } 251 252 // Honor -analyzer-config-help. 253 if (AnOpts.ShowConfigOptionsList) { 254 ento::printAnalyzerConfigList(llvm::outs()); 255 return true; 256 } 257 #endif 258 259 // If there were errors in processing arguments, don't do anything else. 260 if (Clang->getDiagnostics().hasErrorOccurred()) 261 return false; 262 // Create and execute the frontend action. 263 std::unique_ptr<FrontendAction> Act(CreateFrontendAction(*Clang)); 264 if (!Act) 265 return false; 266 bool Success = Clang->ExecuteAction(*Act); 267 if (Clang->getFrontendOpts().DisableFree) 268 llvm::BuryPointer(std::move(Act)); 269 return Success; 270 } 271 272 } // namespace clang 273