clang  8.0.0svn
ExecuteCompilerInvocation.cpp
Go to the documentation of this file.
1 //===--- ExecuteCompilerInvocation.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 // This file holds ExecuteCompilerInvocation(). It is split into its own file to
11 // minimize the impact of pulling in essentially everything else in Clang.
12 //
13 //===----------------------------------------------------------------------===//
14 
18 #include "clang/Config/config.h"
19 #include "clang/Driver/Options.h"
25 #include "clang/Frontend/Utils.h"
28 #include "llvm/Option/OptTable.h"
29 #include "llvm/Option/Option.h"
30 #include "llvm/Support/DynamicLibrary.h"
31 #include "llvm/Support/ErrorHandling.h"
32 using namespace clang;
33 using namespace llvm::opt;
34 
35 namespace clang {
36 
37 static std::unique_ptr<FrontendAction>
39  using namespace clang::frontend;
40  StringRef Action("unknown");
41  (void)Action;
42 
43  switch (CI.getFrontendOpts().ProgramAction) {
44  case ASTDeclList: return llvm::make_unique<ASTDeclListAction>();
45  case ASTDump: return llvm::make_unique<ASTDumpAction>();
46  case ASTPrint: return llvm::make_unique<ASTPrintAction>();
47  case ASTView: return llvm::make_unique<ASTViewAction>();
49  return llvm::make_unique<DumpCompilerOptionsAction>();
50  case DumpRawTokens: return llvm::make_unique<DumpRawTokensAction>();
51  case DumpTokens: return llvm::make_unique<DumpTokensAction>();
52  case EmitAssembly: return llvm::make_unique<EmitAssemblyAction>();
53  case EmitBC: return llvm::make_unique<EmitBCAction>();
54  case EmitHTML: return llvm::make_unique<HTMLPrintAction>();
55  case EmitLLVM: return llvm::make_unique<EmitLLVMAction>();
56  case EmitLLVMOnly: return llvm::make_unique<EmitLLVMOnlyAction>();
57  case EmitCodeGenOnly: return llvm::make_unique<EmitCodeGenOnlyAction>();
58  case EmitObj: return llvm::make_unique<EmitObjAction>();
59  case FixIt: return llvm::make_unique<FixItAction>();
60  case GenerateModule:
61  return llvm::make_unique<GenerateModuleFromModuleMapAction>();
63  return llvm::make_unique<GenerateModuleInterfaceAction>();
65  return llvm::make_unique<GenerateHeaderModuleAction>();
66  case GeneratePCH: return llvm::make_unique<GeneratePCHAction>();
67  case GeneratePTH: return llvm::make_unique<GeneratePTHAction>();
68  case InitOnly: return llvm::make_unique<InitOnlyAction>();
69  case ParseSyntaxOnly: return llvm::make_unique<SyntaxOnlyAction>();
70  case ModuleFileInfo: return llvm::make_unique<DumpModuleInfoAction>();
71  case VerifyPCH: return llvm::make_unique<VerifyPCHAction>();
72  case TemplightDump: return llvm::make_unique<TemplightDumpAction>();
73 
74  case PluginAction: {
75  for (FrontendPluginRegistry::iterator it =
76  FrontendPluginRegistry::begin(), ie = FrontendPluginRegistry::end();
77  it != ie; ++it) {
78  if (it->getName() == CI.getFrontendOpts().ActionName) {
79  std::unique_ptr<PluginASTAction> P(it->instantiate());
80  if ((P->getActionType() != PluginASTAction::ReplaceAction &&
81  P->getActionType() != PluginASTAction::Cmdline) ||
82  !P->ParseArgs(CI, CI.getFrontendOpts().PluginArgs[it->getName()]))
83  return nullptr;
84  return std::move(P);
85  }
86  }
87 
88  CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name)
90  return nullptr;
91  }
92 
93  case PrintDeclContext: return llvm::make_unique<DeclContextPrintAction>();
94  case PrintPreamble: return llvm::make_unique<PrintPreambleAction>();
98  return llvm::make_unique<RewriteIncludesAction>();
99  return llvm::make_unique<PrintPreprocessedAction>();
100  }
101 
102  case RewriteMacros: return llvm::make_unique<RewriteMacrosAction>();
103  case RewriteTest: return llvm::make_unique<RewriteTestAction>();
104 #if CLANG_ENABLE_OBJC_REWRITER
105  case RewriteObjC: return llvm::make_unique<RewriteObjCAction>();
106 #else
107  case RewriteObjC: Action = "RewriteObjC"; break;
108 #endif
109 #if CLANG_ENABLE_ARCMT
110  case MigrateSource:
111  return llvm::make_unique<arcmt::MigrateSourceAction>();
112 #else
113  case MigrateSource: Action = "MigrateSource"; break;
114 #endif
115 #if CLANG_ENABLE_STATIC_ANALYZER
116  case RunAnalysis: return llvm::make_unique<ento::AnalysisAction>();
117 #else
118  case RunAnalysis: Action = "RunAnalysis"; break;
119 #endif
120  case RunPreprocessorOnly: return llvm::make_unique<PreprocessOnlyAction>();
121  }
122 
123 #if !CLANG_ENABLE_ARCMT || !CLANG_ENABLE_STATIC_ANALYZER \
124  || !CLANG_ENABLE_OBJC_REWRITER
125  CI.getDiagnostics().Report(diag::err_fe_action_not_available) << Action;
126  return 0;
127 #else
128  llvm_unreachable("Invalid program action!");
129 #endif
130 }
131 
132 std::unique_ptr<FrontendAction>
134  // Create the underlying action.
135  std::unique_ptr<FrontendAction> Act = CreateFrontendBaseAction(CI);
136  if (!Act)
137  return nullptr;
138 
139  const FrontendOptions &FEOpts = CI.getFrontendOpts();
140 
141  if (FEOpts.FixAndRecompile) {
142  Act = llvm::make_unique<FixItRecompile>(std::move(Act));
143  }
144 
145 #if CLANG_ENABLE_ARCMT
148  // Potentially wrap the base FE action in an ARC Migrate Tool action.
149  switch (FEOpts.ARCMTAction) {
151  break;
153  Act = llvm::make_unique<arcmt::CheckAction>(std::move(Act));
154  break;
156  Act = llvm::make_unique<arcmt::ModifyAction>(std::move(Act));
157  break;
159  Act = llvm::make_unique<arcmt::MigrateAction>(std::move(Act),
160  FEOpts.MTMigrateDir,
161  FEOpts.ARCMTMigrateReportOut,
163  break;
164  }
165 
167  Act = llvm::make_unique<arcmt::ObjCMigrateAction>(std::move(Act),
168  FEOpts.MTMigrateDir,
169  FEOpts.ObjCMTAction);
170  }
171  }
172 #endif
173 
174  // If there are any AST files to merge, create a frontend action
175  // adaptor to perform the merge.
176  if (!FEOpts.ASTMergeFiles.empty())
177  Act = llvm::make_unique<ASTMergeAction>(std::move(Act),
178  FEOpts.ASTMergeFiles);
179 
180  return Act;
181 }
182 
184  // Honor -help.
185  if (Clang->getFrontendOpts().ShowHelp) {
186  std::unique_ptr<OptTable> Opts = driver::createDriverOptTable();
187  Opts->PrintHelp(llvm::outs(), "clang -cc1",
188  "LLVM 'Clang' Compiler: http://clang.llvm.org",
189  /*Include=*/driver::options::CC1Option,
190  /*Exclude=*/0, /*ShowAllAliases=*/false);
191  return true;
192  }
193 
194  // Honor -version.
195  //
196  // FIXME: Use a better -version message?
197  if (Clang->getFrontendOpts().ShowVersion) {
198  llvm::cl::PrintVersionMessage();
199  return true;
200  }
201 
202  // Load any requested plugins.
203  for (unsigned i = 0,
204  e = Clang->getFrontendOpts().Plugins.size(); i != e; ++i) {
205  const std::string &Path = Clang->getFrontendOpts().Plugins[i];
206  std::string Error;
207  if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &Error))
208  Clang->getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
209  << Path << Error;
210  }
211 
212  // Check if any of the loaded plugins replaces the main AST action
213  for (FrontendPluginRegistry::iterator it = FrontendPluginRegistry::begin(),
214  ie = FrontendPluginRegistry::end();
215  it != ie; ++it) {
216  std::unique_ptr<PluginASTAction> P(it->instantiate());
217  if (P->getActionType() == PluginASTAction::ReplaceAction) {
219  Clang->getFrontendOpts().ActionName = it->getName();
220  break;
221  }
222  }
223 
224  // Honor -mllvm.
225  //
226  // FIXME: Remove this, one day.
227  // This should happen AFTER plugins have been loaded!
228  if (!Clang->getFrontendOpts().LLVMArgs.empty()) {
229  unsigned NumArgs = Clang->getFrontendOpts().LLVMArgs.size();
230  auto Args = llvm::make_unique<const char*[]>(NumArgs + 2);
231  Args[0] = "clang (LLVM option parsing)";
232  for (unsigned i = 0; i != NumArgs; ++i)
233  Args[i + 1] = Clang->getFrontendOpts().LLVMArgs[i].c_str();
234  Args[NumArgs + 1] = nullptr;
235  llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args.get());
236  }
237 
238 #if CLANG_ENABLE_STATIC_ANALYZER
239  // Honor -analyzer-checker-help.
240  // This should happen AFTER plugins have been loaded!
241  if (Clang->getAnalyzerOpts()->ShowCheckerHelp) {
242  ento::printCheckerHelp(llvm::outs(), Clang->getFrontendOpts().Plugins);
243  return true;
244  }
245  if (Clang->getAnalyzerOpts()->ShowEnabledCheckerList) {
246  ento::printEnabledCheckerList(llvm::outs(),
247  Clang->getFrontendOpts().Plugins,
248  *Clang->getAnalyzerOpts());
249  }
250 #endif
251 
252  // If there were errors in processing arguments, don't do anything else.
253  if (Clang->getDiagnostics().hasErrorOccurred())
254  return false;
255  // Create and execute the frontend action.
256  std::unique_ptr<FrontendAction> Act(CreateFrontendAction(*Clang));
257  if (!Act)
258  return false;
259  bool Success = Clang->ExecuteAction(*Act);
260  if (Clang->getFrontendOpts().DisableFree)
261  BuryPointer(std::move(Act));
262  return Success;
263 }
264 
265 } // namespace clang
Expand macros but not #includes.
bool hasErrorOccurred() const
Definition: Diagnostic.h:746
enum clang::FrontendOptions::@182 ARCMTAction
Generate pre-compiled module from a module map.
Parse and perform semantic analysis.
Emit a .bc file.
std::unique_ptr< FrontendAction > CreateFrontendAction(CompilerInstance &CI)
Construct the FrontendAction of a compiler invocation based on the options specified for the compiler...
Parse ASTs and print them.
StringRef P
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
void printEnabledCheckerList(raw_ostream &OS, ArrayRef< std::string > plugins, const AnalyzerOptions &opts)
Parse and apply any fixits to the source.
Translate input source into HTML.
static std::unique_ptr< FrontendAction > CreateFrontendBaseAction(CompilerInstance &CI)
std::vector< std::string > ASTMergeFiles
The list of AST files to merge.
Print DeclContext and their Decls.
Action is determined by the cc1 command-line.
Generate LLVM IR, but do not emit anything.
FrontendOptions & getFrontendOpts()
PreprocessorOutputOptions & getPreprocessorOutputOpts()
std::unique_ptr< llvm::opt::OptTable > createDriverOptTable()
AnalyzerOptionsRef getAnalyzerOpts()
unsigned FixAndRecompile
Apply fixes and recompile.
Dump the compiler configuration.
Dump template instantiations.
Dump out preprocessed tokens.
Generate pre-compiled module from a C++ module interface file.
std::vector< std::string > Plugins
The list of plugins to load.
unsigned RewriteIncludes
Preprocess include directives only.
Only execute frontend initialization.
Print the "preamble" of the input file.
Rewriter playground.
unsigned ARCMTMigrateEmitARCErrors
Emit ARC errors even if the migrator can fix them.
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler&#39;s CompilerInvocation object...
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Generate machine code, but don&#39;t emit anything.
Parse ASTs and view them in Graphviz.
Parse ASTs and list Decl nodes.
std::unordered_map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
Load and verify that a PCH file is usable.
unsigned ShowVersion
Show the -version text.
unsigned RewriteImports
Include contents of transitively-imported modules.
unsigned ShowHelp
Show the -help text.
void printCheckerHelp(raw_ostream &OS, ArrayRef< std::string > plugins)
Dataflow Directional Tag Classes.
frontend::ActionKind ProgramAction
The frontend action to perform.
std::string ARCMTMigrateReportOut
FrontendOptions - Options for controlling the behavior of the frontend.
Run a plugin action,.
void BuryPointer(const void *Ptr)
Parse ASTs and dump them.
bool ExecuteCompilerInvocation(CompilerInstance *Clang)
ExecuteCompilerInvocation - Execute the given actions described by the compiler invocation object in ...
unsigned DisableFree
Disable memory freeing on exit.
Generate pre-compiled header.
Generate pre-compiled module from a set of header files.
std::string ActionName
The name of the action to run when using a plugin action.
Run one or more source code analyses.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
std::vector< std::string > LLVMArgs
A list of arguments to forward to LLVM&#39;s option processing; this should only be used for debugging an...
Dump information about a module file.
Generate pre-tokenized header.