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 
15 #include "clang/FrontendTool/Utils.h"
16 #include "clang/ARCMigrate/ARCMTActions.h"
17 #include "clang/CodeGen/CodeGenAction.h"
18 #include "clang/Driver/Options.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/Rewrite/Frontend/FrontendActions.h"
25 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
26 #include "llvm/Option/OptTable.h"
27 #include "llvm/Option/Option.h"
28 #include "llvm/Support/DynamicLibrary.h"
29 #include "llvm/Support/ErrorHandling.h"
30 using namespace clang;
31 using namespace llvm::opt;
32 
33 static FrontendAction *CreateFrontendBaseAction(CompilerInstance &CI) {
34   using namespace clang::frontend;
35 
36   switch (CI.getFrontendOpts().ProgramAction) {
37   case ASTDeclList:            return new ASTDeclListAction();
38   case ASTDump:                return new ASTDumpAction();
39   case ASTPrint:               return new ASTPrintAction();
40   case ASTView:                return new ASTViewAction();
41   case DumpRawTokens:          return new DumpRawTokensAction();
42   case DumpTokens:             return new DumpTokensAction();
43   case EmitAssembly:           return new EmitAssemblyAction();
44   case EmitBC:                 return new EmitBCAction();
45 #ifdef CLANG_ENABLE_REWRITER
46   case EmitHTML:               return new HTMLPrintAction();
47 #else
48   case EmitHTML:               Action = "EmitHTML"; break;
49 #endif
50   case EmitLLVM:               return new EmitLLVMAction();
51   case EmitLLVMOnly:           return new EmitLLVMOnlyAction();
52   case EmitCodeGenOnly:        return new EmitCodeGenOnlyAction();
53   case EmitObj:                return new EmitObjAction();
54 #ifdef CLANG_ENABLE_REWRITER
55   case FixIt:                  return new FixItAction();
56 #else
57   case FixIt:                  Action = "FixIt"; break;
58 #endif
59   case GenerateModule:         return new GenerateModuleAction;
60   case GeneratePCH:            return new GeneratePCHAction;
61   case GeneratePTH:            return new GeneratePTHAction();
62   case InitOnly:               return new InitOnlyAction();
63   case ParseSyntaxOnly:        return new SyntaxOnlyAction();
64   case ModuleFileInfo:         return new DumpModuleInfoAction();
65 
66   case PluginAction: {
67     for (FrontendPluginRegistry::iterator it =
68            FrontendPluginRegistry::begin(), ie = FrontendPluginRegistry::end();
69          it != ie; ++it) {
70       if (it->getName() == CI.getFrontendOpts().ActionName) {
71         OwningPtr<PluginASTAction> P(it->instantiate());
72         if (!P->ParseArgs(CI, CI.getFrontendOpts().PluginArgs))
73           return 0;
74         return P.take();
75       }
76     }
77 
78     CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name)
79       << CI.getFrontendOpts().ActionName;
80     return 0;
81   }
82 
83   case PrintDeclContext:       return new DeclContextPrintAction();
84   case PrintPreamble:          return new PrintPreambleAction();
85   case PrintPreprocessedInput: {
86     if (CI.getPreprocessorOutputOpts().RewriteIncludes) {
87 #ifdef CLANG_ENABLE_REWRITER
88       return new RewriteIncludesAction();
89 #else
90       Action = "RewriteIncludesAction";
91       break;
92 #endif
93     }
94     return new PrintPreprocessedAction();
95   }
96 
97 #ifdef CLANG_ENABLE_REWRITER
98   case RewriteMacros:          return new RewriteMacrosAction();
99   case RewriteObjC:            return new RewriteObjCAction();
100   case RewriteTest:            return new RewriteTestAction();
101 #else
102   case RewriteMacros:          Action = "RewriteMacros"; break;
103   case RewriteObjC:            Action = "RewriteObjC"; break;
104   case RewriteTest:            Action = "RewriteTest"; break;
105 #endif
106 #ifdef CLANG_ENABLE_ARCMT
107   case MigrateSource:          return new arcmt::MigrateSourceAction();
108 #else
109   case MigrateSource:          Action = "MigrateSource"; break;
110 #endif
111 #ifdef CLANG_ENABLE_STATIC_ANALYZER
112   case RunAnalysis:            return new ento::AnalysisAction();
113 #else
114   case RunAnalysis:            Action = "RunAnalysis"; break;
115 #endif
116   case RunPreprocessorOnly:    return new PreprocessOnlyAction();
117   }
118 
119 #if !defined(CLANG_ENABLE_ARCMT) || !defined(CLANG_ENABLE_STATIC_ANALYZER) \
120   || !defined(CLANG_ENABLE_REWRITER)
121   CI.getDiagnostics().Report(diag::err_fe_action_not_available) << Action;
122   return 0;
123 #else
124   llvm_unreachable("Invalid program action!");
125 #endif
126 }
127 
128 static FrontendAction *CreateFrontendAction(CompilerInstance &CI) {
129   // Create the underlying action.
130   FrontendAction *Act = CreateFrontendBaseAction(CI);
131   if (!Act)
132     return 0;
133 
134   const FrontendOptions &FEOpts = CI.getFrontendOpts();
135 
136 #ifdef CLANG_ENABLE_REWRITER
137   if (FEOpts.FixAndRecompile) {
138     Act = new FixItRecompile(Act);
139   }
140 #endif
141 
142 #ifdef CLANG_ENABLE_ARCMT
143   if (CI.getFrontendOpts().ProgramAction != frontend::MigrateSource) {
144     // Potentially wrap the base FE action in an ARC Migrate Tool action.
145     switch (FEOpts.ARCMTAction) {
146     case FrontendOptions::ARCMT_None:
147       break;
148     case FrontendOptions::ARCMT_Check:
149       Act = new arcmt::CheckAction(Act);
150       break;
151     case FrontendOptions::ARCMT_Modify:
152       Act = new arcmt::ModifyAction(Act);
153       break;
154     case FrontendOptions::ARCMT_Migrate:
155       Act = new arcmt::MigrateAction(Act,
156                                      FEOpts.MTMigrateDir,
157                                      FEOpts.ARCMTMigrateReportOut,
158                                      FEOpts.ARCMTMigrateEmitARCErrors);
159       break;
160     }
161 
162     if (FEOpts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
163       Act = new arcmt::ObjCMigrateAction(Act, FEOpts.MTMigrateDir,
164                                          FEOpts.ObjCMTAction);
165     }
166   }
167 #endif
168 
169   // If there are any AST files to merge, create a frontend action
170   // adaptor to perform the merge.
171   if (!FEOpts.ASTMergeFiles.empty())
172     Act = new ASTMergeAction(Act, FEOpts.ASTMergeFiles);
173 
174   return Act;
175 }
176 
177 bool clang::ExecuteCompilerInvocation(CompilerInstance *Clang) {
178   // Honor -help.
179   if (Clang->getFrontendOpts().ShowHelp) {
180     OwningPtr<OptTable> Opts(driver::createDriverOptTable());
181     Opts->PrintHelp(llvm::outs(), "clang -cc1",
182                     "LLVM 'Clang' Compiler: http://clang.llvm.org",
183                     /*Include=*/ driver::options::CC1Option, /*Exclude=*/ 0);
184     return true;
185   }
186 
187   // Honor -version.
188   //
189   // FIXME: Use a better -version message?
190   if (Clang->getFrontendOpts().ShowVersion) {
191     llvm::cl::PrintVersionMessage();
192     return true;
193   }
194 
195   // Load any requested plugins.
196   for (unsigned i = 0,
197          e = Clang->getFrontendOpts().Plugins.size(); i != e; ++i) {
198     const std::string &Path = Clang->getFrontendOpts().Plugins[i];
199     std::string Error;
200     if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Path.c_str(), &Error))
201       Clang->getDiagnostics().Report(diag::err_fe_unable_to_load_plugin)
202         << Path << Error;
203   }
204 
205   // Honor -mllvm.
206   //
207   // FIXME: Remove this, one day.
208   // This should happen AFTER plugins have been loaded!
209   if (!Clang->getFrontendOpts().LLVMArgs.empty()) {
210     unsigned NumArgs = Clang->getFrontendOpts().LLVMArgs.size();
211     const char **Args = new const char*[NumArgs + 2];
212     Args[0] = "clang (LLVM option parsing)";
213     for (unsigned i = 0; i != NumArgs; ++i)
214       Args[i + 1] = Clang->getFrontendOpts().LLVMArgs[i].c_str();
215     Args[NumArgs + 1] = 0;
216     llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args);
217   }
218 
219 #ifdef CLANG_ENABLE_STATIC_ANALYZER
220   // Honor -analyzer-checker-help.
221   // This should happen AFTER plugins have been loaded!
222   if (Clang->getAnalyzerOpts()->ShowCheckerHelp) {
223     ento::printCheckerHelp(llvm::outs(), Clang->getFrontendOpts().Plugins);
224     return true;
225   }
226 #endif
227 
228   // If there were errors in processing arguments, don't do anything else.
229   if (Clang->getDiagnostics().hasErrorOccurred())
230     return false;
231   // Create and execute the frontend action.
232   OwningPtr<FrontendAction> Act(CreateFrontendAction(*Clang));
233   if (!Act)
234     return false;
235   bool Success = Clang->ExecuteAction(*Act);
236   if (Clang->getFrontendOpts().DisableFree)
237     Act.take();
238   return Success;
239 }
240