blob: 980c75200e7ee3228524a532021556fc0fccd13a [file] [log] [blame]
Daniel Dunbarb3375cb2009-11-17 06:02:29 +00001//===--- CompilerInvocation.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/CompilerInvocation.h"
Daniel Dunbar56ac85c2009-12-01 03:16:53 +000011#include "clang/Basic/Diagnostic.h"
12#include "clang/Basic/Version.h"
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +000013#include "clang/Basic/FileManager.h"
Daniel Dunbar56ac85c2009-12-01 03:16:53 +000014#include "clang/Driver/Arg.h"
15#include "clang/Driver/ArgList.h"
16#include "clang/Driver/CC1Options.h"
17#include "clang/Driver/DriverDiagnostic.h"
18#include "clang/Driver/OptTable.h"
19#include "clang/Driver/Option.h"
20#include "clang/Frontend/CompilerInvocation.h"
21#include "clang/Frontend/LangStandard.h"
Sebastian Redl6ab7cd82010-08-18 23:57:17 +000022#include "clang/Serialization/ASTReader.h"
Daniel Dunbar56ac85c2009-12-01 03:16:53 +000023#include "llvm/ADT/OwningPtr.h"
24#include "llvm/ADT/SmallVector.h"
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000025#include "llvm/ADT/StringExtras.h"
Daniel Dunbar56ac85c2009-12-01 03:16:53 +000026#include "llvm/ADT/StringSwitch.h"
Duncan Sands2dc14532010-08-30 09:42:39 +000027#include "llvm/ADT/Triple.h"
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000028#include "llvm/Support/ErrorHandling.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000029#include "llvm/Support/Host.h"
30#include "llvm/Support/Path.h"
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000031using namespace clang;
32
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000033static const char *getAnalysisStoreName(AnalysisStores Kind) {
34 switch (Kind) {
35 default:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +000036 llvm_unreachable("Unknown analysis store!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000037#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
38 case NAME##Model: return CMDFLAG;
39#include "clang/Frontend/Analyses.def"
40 }
41}
42
43static const char *getAnalysisConstraintName(AnalysisConstraints Kind) {
44 switch (Kind) {
45 default:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +000046 llvm_unreachable("Unknown analysis constraints!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000047#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
48 case NAME##Model: return CMDFLAG;
49#include "clang/Frontend/Analyses.def"
50 }
51}
52
53static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) {
54 switch (Kind) {
55 default:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +000056 llvm_unreachable("Unknown analysis client!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000057#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
58 case PD_##NAME: return CMDFLAG;
59#include "clang/Frontend/Analyses.def"
60 }
61}
62
Daniel Dunbar56ac85c2009-12-01 03:16:53 +000063//===----------------------------------------------------------------------===//
64// Serialization (to args)
65//===----------------------------------------------------------------------===//
66
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000067static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts,
68 std::vector<std::string> &Res) {
Argyrios Kyrtzidis116f3642011-02-25 00:09:51 +000069 if (Opts.ShowCheckerHelp)
70 Res.push_back("-analyzer-checker-help");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000071 if (Opts.AnalysisStoreOpt != BasicStoreModel) {
72 Res.push_back("-analyzer-store");
73 Res.push_back(getAnalysisStoreName(Opts.AnalysisStoreOpt));
74 }
75 if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {
76 Res.push_back("-analyzer-constraints");
77 Res.push_back(getAnalysisConstraintName(Opts.AnalysisConstraintsOpt));
78 }
79 if (Opts.AnalysisDiagOpt != PD_HTML) {
80 Res.push_back("-analyzer-output");
81 Res.push_back(getAnalysisDiagClientName(Opts.AnalysisDiagOpt));
82 }
83 if (!Opts.AnalyzeSpecificFunction.empty()) {
84 Res.push_back("-analyze-function");
85 Res.push_back(Opts.AnalyzeSpecificFunction);
86 }
87 if (Opts.AnalyzeAll)
88 Res.push_back("-analyzer-opt-analyze-headers");
89 if (Opts.AnalyzerDisplayProgress)
90 Res.push_back("-analyzer-display-progress");
Ted Kremenekfc576512009-12-07 22:06:12 +000091 if (Opts.AnalyzeNestedBlocks)
92 Res.push_back("-analyzer-opt-analyze-nested-blocks");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000093 if (Opts.EagerlyAssume)
94 Res.push_back("-analyzer-eagerly-assume");
Daniel Dunbar4db166b2009-11-19 05:32:09 +000095 if (!Opts.PurgeDead)
96 Res.push_back("-analyzer-no-purge-dead");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +000097 if (Opts.TrimGraph)
98 Res.push_back("-trim-egraph");
99 if (Opts.VisualizeEGDot)
100 Res.push_back("-analyzer-viz-egraph-graphviz");
Sandeep Patel1040c222011-03-16 19:14:34 +0000101 if (Opts.VisualizeEGUbi)
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000102 Res.push_back("-analyzer-viz-egraph-ubigraph");
Argyrios Kyrtzidis43dee222011-02-14 18:13:31 +0000103
104 for (unsigned i = 0, e = Opts.CheckersControlList.size(); i != e; ++i) {
105 const std::pair<std::string, bool> &opt = Opts.CheckersControlList[i];
106 if (opt.second)
107 Res.push_back("-analyzer-disable-checker");
108 else
109 Res.push_back("-analyzer-checker");
110 Res.push_back(opt.first);
111 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000112}
113
114static void CodeGenOptsToArgs(const CodeGenOptions &Opts,
115 std::vector<std::string> &Res) {
116 if (Opts.DebugInfo)
117 Res.push_back("-g");
118 if (Opts.DisableLLVMOpts)
119 Res.push_back("-disable-llvm-optzns");
120 if (Opts.DisableRedZone)
121 Res.push_back("-disable-red-zone");
Daniel Dunbarf2d8b9f2009-12-18 02:43:17 +0000122 if (!Opts.DwarfDebugFlags.empty()) {
123 Res.push_back("-dwarf-debug-flags");
124 Res.push_back(Opts.DwarfDebugFlags);
125 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000126 if (!Opts.MergeAllConstants)
127 Res.push_back("-fno-merge-all-constants");
Daniel Dunbar50a44872009-11-20 17:23:30 +0000128 if (Opts.NoCommon)
129 Res.push_back("-fno-common");
John McCall32096692011-03-18 02:56:14 +0000130 if (Opts.ForbidGuardVariables)
131 Res.push_back("-fforbid-guard-variables");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000132 if (Opts.NoImplicitFloat)
133 Res.push_back("-no-implicit-float");
Daniel Dunbar1ad66482010-07-01 01:31:45 +0000134 if (Opts.OmitLeafFramePointer)
135 Res.push_back("-momit-leaf-frame-pointer");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000136 if (Opts.OptimizeSize) {
137 assert(Opts.OptimizationLevel == 2 && "Invalid options!");
138 Res.push_back("-Os");
Daniel Dunbar1be3b3b2009-11-19 20:54:59 +0000139 } else if (Opts.OptimizationLevel != 0)
140 Res.push_back("-O" + llvm::utostr(Opts.OptimizationLevel));
Daniel Dunbar7d065d02009-11-29 02:38:34 +0000141 if (!Opts.MainFileName.empty()) {
142 Res.push_back("-main-file-name");
143 Res.push_back(Opts.MainFileName);
144 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000145 // SimplifyLibCalls is only derived.
146 // TimePasses is only derived.
147 // UnitAtATime is unused.
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000148 // Inlining is only derived.
Michael J. Spencer20249a12010-10-21 03:16:25 +0000149
Eric Christopherf84d4092010-08-07 23:08:14 +0000150 // UnrollLoops is derived, but also accepts an option, no
151 // harm in pushing it back here.
152 if (Opts.UnrollLoops)
153 Res.push_back("-funroll-loops");
Chris Lattnerbbea7162010-04-13 00:38:24 +0000154 if (Opts.DataSections)
155 Res.push_back("-fdata-sections");
156 if (Opts.FunctionSections)
157 Res.push_back("-ffunction-sections");
Daniel Dunbarf219e7c2009-11-29 07:18:39 +0000158 if (Opts.AsmVerbose)
159 Res.push_back("-masm-verbose");
160 if (!Opts.CodeModel.empty()) {
161 Res.push_back("-mcode-model");
162 Res.push_back(Opts.CodeModel);
163 }
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000164 if (!Opts.CXAAtExit)
165 Res.push_back("-fno-use-cxa-atexit");
166 if (Opts.CXXCtorDtorAliases)
167 Res.push_back("-mconstructor-aliases");
Daniel Dunbarf219e7c2009-11-29 07:18:39 +0000168 if (!Opts.DebugPass.empty()) {
169 Res.push_back("-mdebug-pass");
170 Res.push_back(Opts.DebugPass);
171 }
172 if (Opts.DisableFPElim)
173 Res.push_back("-mdisable-fp-elim");
Daniel Dunbar3b315262009-11-30 08:42:00 +0000174 if (!Opts.FloatABI.empty()) {
175 Res.push_back("-mfloat-abi");
176 Res.push_back(Opts.FloatABI);
177 }
Daniel Dunbarf219e7c2009-11-29 07:18:39 +0000178 if (!Opts.LimitFloatPrecision.empty()) {
179 Res.push_back("-mlimit-float-precision");
180 Res.push_back(Opts.LimitFloatPrecision);
181 }
182 if (Opts.NoZeroInitializedInBSS)
183 Res.push_back("-mno-zero-initialized-bss");
Daniel Dunbarf643b9b2010-04-24 17:56:46 +0000184 switch (Opts.getObjCDispatchMethod()) {
185 case CodeGenOptions::Legacy:
186 break;
187 case CodeGenOptions::Mixed:
188 Res.push_back("-fobjc-dispatch-method=mixed");
189 break;
190 case CodeGenOptions::NonLegacy:
191 Res.push_back("-fobjc-dispatch-method=non-legacy");
192 break;
193 }
Daniel Dunbar17d3fea2011-02-09 17:54:19 +0000194 if (Opts.NumRegisterParameters) {
195 Res.push_back("-mregparm");
196 Res.push_back(llvm::utostr(Opts.NumRegisterParameters));
197 }
Daniel Dunbar4ecc9b72010-05-27 05:39:39 +0000198 if (Opts.RelaxAll)
199 Res.push_back("-mrelax-all");
Daniel Dunbar3b315262009-11-30 08:42:00 +0000200 if (Opts.SoftFloat)
201 Res.push_back("-msoft-float");
Daniel Dunbarf219e7c2009-11-29 07:18:39 +0000202 if (Opts.UnwindTables)
203 Res.push_back("-munwind-tables");
204 if (Opts.RelocationModel != "pic") {
205 Res.push_back("-mrelocation-model");
206 Res.push_back(Opts.RelocationModel);
207 }
John McCallb689afb2010-02-13 03:50:24 +0000208 if (!Opts.VerifyModule)
209 Res.push_back("-disable-llvm-verifier");
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000210 for (unsigned i = 0, e = Opts.BackendOptions.size(); i != e; ++i) {
211 Res.push_back("-backend-option");
212 Res.push_back(Opts.BackendOptions[i]);
213 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000214}
215
216static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts,
217 std::vector<std::string> &Res) {
218 if (Opts.IncludeSystemHeaders)
219 Res.push_back("-sys-header-deps");
Daniel Dunbareef63e02011-02-02 15:41:17 +0000220 if (Opts.ShowHeaderIncludes)
221 Res.push_back("-H");
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000222 if (!Opts.HeaderIncludeOutputFile.empty()) {
223 Res.push_back("-header-include-file");
224 Res.push_back(Opts.HeaderIncludeOutputFile);
225 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000226 if (Opts.UsePhonyTargets)
227 Res.push_back("-MP");
228 if (!Opts.OutputFile.empty()) {
229 Res.push_back("-dependency-file");
230 Res.push_back(Opts.OutputFile);
231 }
232 for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i) {
233 Res.push_back("-MT");
234 Res.push_back(Opts.Targets[i]);
235 }
236}
237
238static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts,
239 std::vector<std::string> &Res) {
240 if (Opts.IgnoreWarnings)
241 Res.push_back("-w");
242 if (Opts.NoRewriteMacros)
243 Res.push_back("-Wno-rewrite-macros");
244 if (Opts.Pedantic)
245 Res.push_back("-pedantic");
246 if (Opts.PedanticErrors)
247 Res.push_back("-pedantic-errors");
248 if (!Opts.ShowColumn)
249 Res.push_back("-fno-show-column");
250 if (!Opts.ShowLocation)
251 Res.push_back("-fno-show-source-location");
252 if (!Opts.ShowCarets)
253 Res.push_back("-fno-caret-diagnostics");
254 if (!Opts.ShowFixits)
255 Res.push_back("-fno-diagnostics-fixit-info");
256 if (Opts.ShowSourceRanges)
257 Res.push_back("-fdiagnostics-print-source-range-info");
Douglas Gregor4786c152010-08-19 20:24:43 +0000258 if (Opts.ShowParseableFixits)
259 Res.push_back("-fdiagnostics-parseable-fixits");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000260 if (Opts.ShowColors)
261 Res.push_back("-fcolor-diagnostics");
262 if (Opts.VerifyDiagnostics)
263 Res.push_back("-verify");
264 if (Opts.ShowOptionNames)
265 Res.push_back("-fdiagnostics-show-option");
Chris Lattner6fbe8392010-05-04 21:55:25 +0000266 if (Opts.ShowCategories == 1)
267 Res.push_back("-fdiagnostics-show-category=id");
268 else if (Opts.ShowCategories == 2)
269 Res.push_back("-fdiagnostics-show-category=name");
Chris Lattnerc1002142010-04-07 20:37:06 +0000270 if (Opts.ErrorLimit) {
271 Res.push_back("-ferror-limit");
272 Res.push_back(llvm::utostr(Opts.ErrorLimit));
273 }
Douglas Gregor6c1cb992010-05-04 17:13:42 +0000274 if (Opts.MacroBacktraceLimit
275 != DiagnosticOptions::DefaultMacroBacktraceLimit) {
276 Res.push_back("-fmacro-backtrace-limit");
277 Res.push_back(llvm::utostr(Opts.MacroBacktraceLimit));
278 }
279 if (Opts.TemplateBacktraceLimit
280 != DiagnosticOptions::DefaultTemplateBacktraceLimit) {
Douglas Gregor575cf372010-04-20 07:18:24 +0000281 Res.push_back("-ftemplate-backtrace-limit");
282 Res.push_back(llvm::utostr(Opts.TemplateBacktraceLimit));
283 }
284
Chris Lattner52388f92010-01-13 03:06:50 +0000285 if (Opts.TabStop != DiagnosticOptions::DefaultTabStop) {
Chris Lattner124fca52010-01-09 21:54:33 +0000286 Res.push_back("-ftabstop");
287 Res.push_back(llvm::utostr(Opts.TabStop));
288 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000289 if (Opts.MessageLength) {
290 Res.push_back("-fmessage-length");
291 Res.push_back(llvm::utostr(Opts.MessageLength));
292 }
293 if (!Opts.DumpBuildInformation.empty()) {
294 Res.push_back("-dump-build-information");
295 Res.push_back(Opts.DumpBuildInformation);
296 }
297 for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i)
298 Res.push_back("-W" + Opts.Warnings[i]);
299}
300
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +0000301static const char *getInputKindName(InputKind Kind) {
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000302 switch (Kind) {
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +0000303 case IK_None: break;
304 case IK_AST: return "ast";
305 case IK_Asm: return "assembler-with-cpp";
306 case IK_C: return "c";
307 case IK_CXX: return "c++";
Daniel Dunbarfaddc3e2010-06-07 23:26:47 +0000308 case IK_LLVM_IR: return "ir";
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +0000309 case IK_ObjC: return "objective-c";
310 case IK_ObjCXX: return "objective-c++";
311 case IK_OpenCL: return "cl";
Peter Collingbourne895fcca2010-12-01 03:15:20 +0000312 case IK_CUDA: return "cuda";
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +0000313 case IK_PreprocessedC: return "cpp-output";
314 case IK_PreprocessedCXX: return "c++-cpp-output";
315 case IK_PreprocessedObjC: return "objective-c-cpp-output";
316 case IK_PreprocessedObjCXX:return "objective-c++-cpp-output";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000317 }
318
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +0000319 llvm_unreachable("Unexpected language kind!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000320 return 0;
321}
322
323static const char *getActionName(frontend::ActionKind Kind) {
324 switch (Kind) {
325 case frontend::PluginAction:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +0000326 llvm_unreachable("Invalid kind!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000327
328 case frontend::ASTDump: return "-ast-dump";
John McCallf3514242010-11-24 11:21:45 +0000329 case frontend::ASTDumpXML: return "-ast-dump-xml";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000330 case frontend::ASTPrint: return "-ast-print";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000331 case frontend::ASTView: return "-ast-view";
Douglas Gregorf78cc432010-05-07 15:41:56 +0000332 case frontend::BoostCon: return "-boostcon";
Sebastian Redle55fd872010-08-16 18:17:11 +0000333 case frontend::CreateModule: return "-create-module";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000334 case frontend::DumpRawTokens: return "-dump-raw-tokens";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000335 case frontend::DumpTokens: return "-dump-tokens";
336 case frontend::EmitAssembly: return "-S";
337 case frontend::EmitBC: return "-emit-llvm-bc";
338 case frontend::EmitHTML: return "-emit-html";
339 case frontend::EmitLLVM: return "-emit-llvm";
340 case frontend::EmitLLVMOnly: return "-emit-llvm-only";
Daniel Dunbar32148ce2010-05-25 18:41:01 +0000341 case frontend::EmitCodeGenOnly: return "-emit-codegen-only";
Daniel Dunbarda1573f2010-02-03 01:18:43 +0000342 case frontend::EmitObj: return "-emit-obj";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000343 case frontend::FixIt: return "-fixit";
344 case frontend::GeneratePCH: return "-emit-pch";
345 case frontend::GeneratePTH: return "-emit-pth";
Daniel Dunbar27585952010-03-19 19:44:04 +0000346 case frontend::InitOnly: return "-init-only";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000347 case frontend::ParseSyntaxOnly: return "-fsyntax-only";
348 case frontend::PrintDeclContext: return "-print-decl-contexts";
Douglas Gregorf033f1d2010-07-20 20:18:03 +0000349 case frontend::PrintPreamble: return "-print-preamble";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000350 case frontend::PrintPreprocessedInput: return "-E";
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000351 case frontend::RewriteMacros: return "-rewrite-macros";
352 case frontend::RewriteObjC: return "-rewrite-objc";
353 case frontend::RewriteTest: return "-rewrite-test";
354 case frontend::RunAnalysis: return "-analyze";
355 case frontend::RunPreprocessorOnly: return "-Eonly";
356 }
357
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +0000358 llvm_unreachable("Unexpected language kind!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000359 return 0;
360}
361
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000362static void FileSystemOptsToArgs(const FileSystemOptions &Opts,
363 std::vector<std::string> &Res) {
364 if (!Opts.WorkingDir.empty()) {
365 Res.push_back("-working-directory");
366 Res.push_back(Opts.WorkingDir);
367 }
368}
369
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000370static void FrontendOptsToArgs(const FrontendOptions &Opts,
371 std::vector<std::string> &Res) {
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000372 if (Opts.DisableFree)
373 Res.push_back("-disable-free");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000374 if (Opts.RelocatablePCH)
375 Res.push_back("-relocatable-pch");
Sebastian Redld6ac4522010-07-09 00:00:58 +0000376 if (Opts.ChainedPCH)
377 Res.push_back("-chained-pch");
Daniel Dunbar9b5e9ae2009-12-03 07:01:58 +0000378 if (Opts.ShowHelp)
379 Res.push_back("-help");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000380 if (Opts.ShowMacrosInCodeCompletion)
381 Res.push_back("-code-completion-macros");
Douglas Gregord8e8a582010-05-25 21:41:55 +0000382 if (Opts.ShowCodePatternsInCodeCompletion)
383 Res.push_back("-code-completion-patterns");
Douglas Gregor8071e422010-08-15 06:18:01 +0000384 if (!Opts.ShowGlobalSymbolsInCodeCompletion)
385 Res.push_back("-no-code-completion-globals");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000386 if (Opts.ShowStats)
Daniel Dunbareb01ac82009-11-25 10:14:52 +0000387 Res.push_back("-print-stats");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000388 if (Opts.ShowTimers)
389 Res.push_back("-ftime-report");
Daniel Dunbar9b5e9ae2009-12-03 07:01:58 +0000390 if (Opts.ShowVersion)
391 Res.push_back("-version");
Nick Lewycky1450f262010-08-13 17:31:00 +0000392 if (Opts.FixWhatYouCan)
393 Res.push_back("-fix-what-you-can");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000394
395 bool NeedLang = false;
396 for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i)
397 if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].second) !=
398 Opts.Inputs[i].first)
399 NeedLang = true;
400 if (NeedLang) {
401 Res.push_back("-x");
402 Res.push_back(getInputKindName(Opts.Inputs[0].first));
403 }
404 for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) {
405 assert((!NeedLang || Opts.Inputs[i].first == Opts.Inputs[0].first) &&
406 "Unable to represent this input vector!");
407 Res.push_back(Opts.Inputs[i].second);
408 }
409
410 if (!Opts.OutputFile.empty()) {
411 Res.push_back("-o");
412 Res.push_back(Opts.OutputFile);
413 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000414 if (!Opts.CodeCompletionAt.FileName.empty()) {
415 Res.push_back("-code-completion-at");
416 Res.push_back(Opts.CodeCompletionAt.FileName + ":" +
417 llvm::utostr(Opts.CodeCompletionAt.Line) + ":" +
418 llvm::utostr(Opts.CodeCompletionAt.Column));
419 }
Douglas Gregor91a230a2011-02-17 19:04:40 +0000420 if (Opts.ProgramAction != frontend::PluginAction)
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000421 Res.push_back(getActionName(Opts.ProgramAction));
422 if (!Opts.ActionName.empty()) {
423 Res.push_back("-plugin");
424 Res.push_back(Opts.ActionName);
Daniel Dunbar3177aae2010-06-16 16:59:23 +0000425 for(unsigned i = 0, e = Opts.PluginArgs.size(); i != e; ++i) {
426 Res.push_back("-plugin-arg-" + Opts.ActionName);
427 Res.push_back(Opts.PluginArgs[i]);
428 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000429 }
Daniel Dunbarefba2272009-12-03 05:11:05 +0000430 for (unsigned i = 0, e = Opts.Plugins.size(); i != e; ++i) {
431 Res.push_back("-load");
432 Res.push_back(Opts.Plugins[i]);
433 }
Nico Weber5aa74af2011-01-25 20:34:14 +0000434 for (unsigned i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
435 Res.push_back("-add-plugin");
436 Res.push_back(Opts.AddPluginActions[i]);
Nico Weberf25649c2011-01-29 21:21:49 +0000437 for(unsigned ai = 0, ae = Opts.AddPluginArgs.size(); ai != ae; ++ai) {
438 Res.push_back("-plugin-arg-" + Opts.AddPluginActions[i]);
439 Res.push_back(Opts.AddPluginArgs[i][ai]);
440 }
Nico Weber5aa74af2011-01-25 20:34:14 +0000441 }
Douglas Gregor9bed8792010-02-09 19:21:46 +0000442 for (unsigned i = 0, e = Opts.ASTMergeFiles.size(); i != e; ++i) {
443 Res.push_back("-ast-merge");
444 Res.push_back(Opts.ASTMergeFiles[i]);
445 }
Sebastian Redle55fd872010-08-16 18:17:11 +0000446 for (unsigned i = 0, e = Opts.Modules.size(); i != e; ++i) {
447 Res.push_back("-import-module");
448 Res.push_back(Opts.Modules[i]);
449 }
Daniel Dunbar3f87fb02010-04-15 06:09:03 +0000450 for (unsigned i = 0, e = Opts.LLVMArgs.size(); i != e; ++i) {
451 Res.push_back("-mllvm");
452 Res.push_back(Opts.LLVMArgs[i]);
453 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000454}
455
456static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts,
457 std::vector<std::string> &Res) {
Daniel Dunbarc59dc922009-11-19 05:32:21 +0000458 if (Opts.Sysroot != "/") {
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000459 Res.push_back("-isysroot");
460 Res.push_back(Opts.Sysroot);
461 }
462
463 /// User specified include entries.
464 for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) {
465 const HeaderSearchOptions::Entry &E = Opts.UserEntries[i];
Daniel Dunbard8c78062009-11-26 02:13:54 +0000466 if (E.IsFramework && (E.Group != frontend::Angled || !E.IsUserSupplied))
Chris Lattner83e7a782010-04-07 22:58:06 +0000467 llvm::report_fatal_error("Invalid option set!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000468 if (E.IsUserSupplied) {
469 if (E.Group == frontend::After) {
470 Res.push_back("-idirafter");
471 } else if (E.Group == frontend::Quoted) {
Daniel Dunbard8c78062009-11-26 02:13:54 +0000472 Res.push_back("-iquote");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000473 } else if (E.Group == frontend::System) {
474 Res.push_back("-isystem");
Joerg Sonnenberger2df66472011-02-22 00:40:56 +0000475 } else if (E.Group == frontend::CXXSystem) {
476 Res.push_back("-cxx-isystem");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000477 } else {
478 assert(E.Group == frontend::Angled && "Invalid group!");
479 Res.push_back(E.IsFramework ? "-F" : "-I");
480 }
481 } else {
482 if (E.Group != frontend::Angled && E.Group != frontend::System)
Chris Lattner83e7a782010-04-07 22:58:06 +0000483 llvm::report_fatal_error("Invalid option set!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000484 Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
485 "-iwithprefix");
486 }
487 Res.push_back(E.Path);
488 }
489
490 if (!Opts.EnvIncPath.empty()) {
491 // FIXME: Provide an option for this, and move env detection to driver.
Chris Lattner83e7a782010-04-07 22:58:06 +0000492 llvm::report_fatal_error("Not yet implemented!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000493 }
494 if (!Opts.CEnvIncPath.empty()) {
495 // FIXME: Provide an option for this, and move env detection to driver.
Chris Lattner83e7a782010-04-07 22:58:06 +0000496 llvm::report_fatal_error("Not yet implemented!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000497 }
498 if (!Opts.ObjCEnvIncPath.empty()) {
499 // FIXME: Provide an option for this, and move env detection to driver.
Chris Lattner83e7a782010-04-07 22:58:06 +0000500 llvm::report_fatal_error("Not yet implemented!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000501 }
502 if (!Opts.CXXEnvIncPath.empty()) {
503 // FIXME: Provide an option for this, and move env detection to driver.
Chris Lattner83e7a782010-04-07 22:58:06 +0000504 llvm::report_fatal_error("Not yet implemented!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000505 }
506 if (!Opts.ObjCXXEnvIncPath.empty()) {
507 // FIXME: Provide an option for this, and move env detection to driver.
Chris Lattner83e7a782010-04-07 22:58:06 +0000508 llvm::report_fatal_error("Not yet implemented!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000509 }
Daniel Dunbar8b9adfe2009-12-15 00:06:45 +0000510 if (!Opts.ResourceDir.empty()) {
511 Res.push_back("-resource-dir");
512 Res.push_back(Opts.ResourceDir);
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000513 }
514 if (!Opts.UseStandardIncludes)
515 Res.push_back("-nostdinc");
Douglas Gregor4c2bcad2010-03-24 20:13:48 +0000516 if (!Opts.UseStandardCXXIncludes)
517 Res.push_back("-nostdinc++");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000518 if (Opts.Verbose)
519 Res.push_back("-v");
520}
521
522static void LangOptsToArgs(const LangOptions &Opts,
523 std::vector<std::string> &Res) {
524 LangOptions DefaultLangOpts;
525
526 // FIXME: Need to set -std to get all the implicit options.
527
528 // FIXME: We want to only pass options relative to the defaults, which
529 // requires constructing a target. :(
530 //
531 // It would be better to push the all target specific choices into the driver,
532 // so that everything below that was more uniform.
533
534 if (Opts.Trigraphs)
535 Res.push_back("-trigraphs");
536 // Implicit based on the input kind:
537 // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
538 // Implicit based on the input language standard:
539 // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
540 if (Opts.DollarIdents)
541 Res.push_back("-fdollars-in-identifiers");
Chandler Carrutheb5d7b72010-04-17 20:17:31 +0000542 if (Opts.GNUMode && !Opts.GNUKeywords)
543 Res.push_back("-fno-gnu-keywords");
544 if (!Opts.GNUMode && Opts.GNUKeywords)
545 Res.push_back("-fgnu-keywords");
Daniel Dunbara51ca522009-11-17 09:15:57 +0000546 if (Opts.Microsoft)
Daniel Dunbar8663b182009-12-16 20:10:18 +0000547 Res.push_back("-fms-extensions");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000548 if (Opts.MSCVersion != 0)
549 Res.push_back("-fmsc-version=" + llvm::utostr(Opts.MSCVersion));
Dawn Perchik400b6072010-09-02 23:59:25 +0000550 if (Opts.Borland)
551 Res.push_back("-fborland-extensions");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000552 if (Opts.ObjCNonFragileABI)
553 Res.push_back("-fobjc-nonfragile-abi");
Fariborz Jahanian412e7982010-02-09 19:31:38 +0000554 if (Opts.ObjCNonFragileABI2)
Fariborz Jahanian112c3302011-01-04 20:05:20 +0000555 Res.push_back("-fobjc-nonfragile-abi");
Ted Kremenekc32647d2010-12-23 21:35:43 +0000556 if (Opts.ObjCDefaultSynthProperties)
557 Res.push_back("-fobjc-default-synthesize-properties");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000558 // NoInline is implicit.
559 if (!Opts.CXXOperatorNames)
560 Res.push_back("-fno-operator-names");
561 if (Opts.PascalStrings)
562 Res.push_back("-fpascal-strings");
Mike Stump9c276ae2009-12-12 01:27:46 +0000563 if (Opts.CatchUndefined)
564 Res.push_back("-fcatch-undefined-behavior");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000565 if (Opts.WritableStrings)
566 Res.push_back("-fwritable-strings");
John McCall4b7a8342010-03-15 10:54:44 +0000567 if (Opts.ConstStrings)
568 Res.push_back("-Wwrite-strings");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000569 if (!Opts.LaxVectorConversions)
570 Res.push_back("-fno-lax-vector-conversions");
571 if (Opts.AltiVec)
572 Res.push_back("-faltivec");
Daniel Dunbar1be3b3b2009-11-19 20:54:59 +0000573 if (Opts.Exceptions)
574 Res.push_back("-fexceptions");
Anders Carlsson0761e442011-02-23 03:16:42 +0000575 if (Opts.ObjCExceptions)
576 Res.push_back("-fobjc-exceptions");
577 if (Opts.CXXExceptions)
578 Res.push_back("-fcxx-exceptions");
Daniel Dunbar73482882010-02-10 18:48:44 +0000579 if (Opts.SjLjExceptions)
580 Res.push_back("-fsjlj-exceptions");
Daniel Dunbar2ed42282011-03-18 21:23:38 +0000581 if (Opts.TraditionalCPP)
582 Res.push_back("-traditional-cpp");
Mike Stumpde050572009-12-02 18:57:08 +0000583 if (!Opts.RTTI)
Daniel Dunbar4db166b2009-11-19 05:32:09 +0000584 Res.push_back("-fno-rtti");
Douglas Gregor6f755502011-02-01 15:15:22 +0000585 if (Opts.MSBitfields)
586 Res.push_back("-mms-bitfields");
Daniel Dunbarc5a97ec2009-11-17 07:07:28 +0000587 if (!Opts.NeXTRuntime)
588 Res.push_back("-fgnu-runtime");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000589 if (Opts.Freestanding)
590 Res.push_back("-ffreestanding");
591 if (Opts.NoBuiltin)
592 Res.push_back("-fno-builtin");
Nuno Lopesfc284482009-12-16 16:59:22 +0000593 if (!Opts.AssumeSaneOperatorNew)
594 Res.push_back("-fno-assume-sane-operator-new");
Anders Carlssona508b7d2010-02-06 23:23:06 +0000595 if (!Opts.ThreadsafeStatics)
596 Res.push_back("-fno-threadsafe-statics");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000597 if (Opts.POSIXThreads)
598 Res.push_back("-pthread");
Daniel Dunbara51ca522009-11-17 09:15:57 +0000599 if (Opts.Blocks)
Daniel Dunbare50c1672009-11-29 05:52:21 +0000600 Res.push_back("-fblocks");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000601 if (Opts.EmitAllDecls)
602 Res.push_back("-femit-all-decls");
Dan Gohmanc31176d2010-01-08 02:20:44 +0000603 if (Opts.MathErrno)
604 Res.push_back("-fmath-errno");
Chris Lattnera4d71452010-06-26 21:25:03 +0000605 switch (Opts.getSignedOverflowBehavior()) {
606 case LangOptions::SOB_Undefined: break;
607 case LangOptions::SOB_Defined: Res.push_back("-fwrapv"); break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000608 case LangOptions::SOB_Trapping:
David Chisnall7f18e672010-09-17 18:29:54 +0000609 Res.push_back("-ftrapv"); break;
610 if (!Opts.OverflowHandler.empty()) {
611 Res.push_back("-ftrapv-handler");
612 Res.push_back(Opts.OverflowHandler);
613 }
Chris Lattnera4d71452010-06-26 21:25:03 +0000614 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000615 if (Opts.HeinousExtensions)
616 Res.push_back("-fheinous-gnu-extensions");
617 // Optimize is implicit.
618 // OptimizeSize is implicit.
619 if (Opts.Static)
620 Res.push_back("-static-define");
Daniel Dunbarfb937b82010-04-15 15:06:22 +0000621 if (Opts.DumpRecordLayouts)
622 Res.push_back("-fdump-record-layouts");
Anders Carlsson046c2942010-04-17 20:15:18 +0000623 if (Opts.DumpVTableLayouts)
Daniel Dunbarfb937b82010-04-15 15:06:22 +0000624 Res.push_back("-fdump-vtable-layouts");
625 if (Opts.NoBitFieldTypeAlign)
626 Res.push_back("-fno-bitfield-type-alignment");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000627 if (Opts.PICLevel) {
628 Res.push_back("-pic-level");
629 Res.push_back(llvm::utostr(Opts.PICLevel));
630 }
631 if (Opts.ObjCGCBitmapPrint)
632 Res.push_back("-print-ivar-layout");
Fariborz Jahanian33e982b2010-04-22 20:26:39 +0000633 if (Opts.NoConstantCFStrings)
634 Res.push_back("-fno-constant-cfstrings");
John McCall7002f4c2010-04-09 19:03:51 +0000635 if (!Opts.AccessControl)
636 Res.push_back("-fno-access-control");
Daniel Dunbar1be3b3b2009-11-19 20:54:59 +0000637 if (!Opts.CharIsSigned)
Daniel Dunbare50c1672009-11-29 05:52:21 +0000638 Res.push_back("-fno-signed-char");
Daniel Dunbar1be3b3b2009-11-19 20:54:59 +0000639 if (Opts.ShortWChar)
640 Res.push_back("-fshort-wchar");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000641 if (!Opts.ElideConstructors)
642 Res.push_back("-fno-elide-constructors");
643 if (Opts.getGCMode() != LangOptions::NonGC) {
644 if (Opts.getGCMode() == LangOptions::HybridGC) {
645 Res.push_back("-fobjc-gc");
646 } else {
647 assert(Opts.getGCMode() == LangOptions::GCOnly && "Invalid GC mode!");
648 Res.push_back("-fobjc-gc-only");
649 }
650 }
Fariborz Jahanianb466d012011-01-07 01:05:02 +0000651 if (Opts.AppleKext)
652 Res.push_back("-fapple-kext");
653
John McCall1fb0caa2010-10-22 21:05:15 +0000654 if (Opts.getVisibilityMode() != DefaultVisibility) {
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000655 Res.push_back("-fvisibility");
John McCall1fb0caa2010-10-22 21:05:15 +0000656 if (Opts.getVisibilityMode() == HiddenVisibility) {
Daniel Dunbar1be3b3b2009-11-19 20:54:59 +0000657 Res.push_back("hidden");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000658 } else {
John McCall1fb0caa2010-10-22 21:05:15 +0000659 assert(Opts.getVisibilityMode() == ProtectedVisibility &&
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000660 "Invalid visibility!");
661 Res.push_back("protected");
662 }
663 }
Douglas Gregor7cf84d62010-06-15 17:05:35 +0000664 if (Opts.InlineVisibilityHidden)
665 Res.push_back("-fvisibility-inlines-hidden");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000666
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000667 if (Opts.getStackProtectorMode() != 0) {
668 Res.push_back("-stack-protector");
669 Res.push_back(llvm::utostr(Opts.getStackProtectorMode()));
670 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000671 if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) {
672 Res.push_back("-ftemplate-depth");
673 Res.push_back(llvm::utostr(Opts.InstantiationDepth));
674 }
Daniel Dunbar1b096952009-11-29 02:38:47 +0000675 if (!Opts.ObjCConstantStringClass.empty()) {
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000676 Res.push_back("-fconstant-string-class");
677 Res.push_back(Opts.ObjCConstantStringClass);
678 }
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000679 if (Opts.FakeAddressSpaceMap)
680 Res.push_back("-ffake-address-space-map");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000681}
682
683static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
684 std::vector<std::string> &Res) {
685 for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
Daniel Dunbar0ff679f2009-11-26 02:14:07 +0000686 Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") +
687 Opts.Macros[i].first);
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000688 for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
Daniel Dunbar0ff679f2009-11-26 02:14:07 +0000689 // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000690 Res.push_back("-include");
691 Res.push_back(Opts.Includes[i]);
692 }
693 for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) {
694 Res.push_back("-imacros");
Daniel Dunbar0ff679f2009-11-26 02:14:07 +0000695 Res.push_back(Opts.MacroIncludes[i]);
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000696 }
697 if (!Opts.UsePredefines)
698 Res.push_back("-undef");
Douglas Gregor94dc8f62010-03-19 16:15:56 +0000699 if (Opts.DetailedRecord)
700 Res.push_back("-detailed-preprocessing-record");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000701 if (!Opts.ImplicitPCHInclude.empty()) {
Daniel Dunbar0ff679f2009-11-26 02:14:07 +0000702 Res.push_back("-include-pch");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000703 Res.push_back(Opts.ImplicitPCHInclude);
704 }
705 if (!Opts.ImplicitPTHInclude.empty()) {
Daniel Dunbar0ff679f2009-11-26 02:14:07 +0000706 Res.push_back("-include-pth");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000707 Res.push_back(Opts.ImplicitPTHInclude);
708 }
709 if (!Opts.TokenCache.empty()) {
Daniel Dunbar0ff679f2009-11-26 02:14:07 +0000710 if (Opts.ImplicitPTHInclude.empty()) {
711 Res.push_back("-token-cache");
712 Res.push_back(Opts.TokenCache);
713 } else
714 assert(Opts.ImplicitPTHInclude == Opts.TokenCache &&
715 "Unsupported option combination!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000716 }
Argyrios Kyrtzidisb0f4b9a2011-03-09 17:21:42 +0000717 for (unsigned i = 0, e = Opts.ChainedIncludes.size(); i != e; ++i) {
718 Res.push_back("-chain-include");
719 Res.push_back(Opts.ChainedIncludes[i]);
720 }
Daniel Dunbare14b5f52009-12-03 05:11:16 +0000721 for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) {
722 Res.push_back("-remap-file");
723 Res.push_back(Opts.RemappedFiles[i].first + ";" +
724 Opts.RemappedFiles[i].second);
725 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000726}
727
728static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
729 std::vector<std::string> &Res) {
730 if (!Opts.ShowCPP && !Opts.ShowMacros)
Chris Lattner83e7a782010-04-07 22:58:06 +0000731 llvm::report_fatal_error("Invalid option combination!");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000732
733 if (Opts.ShowCPP && Opts.ShowMacros)
734 Res.push_back("-dD");
735 else if (!Opts.ShowCPP && Opts.ShowMacros)
736 Res.push_back("-dM");
737
738 if (!Opts.ShowLineMarkers)
739 Res.push_back("-P");
740 if (Opts.ShowComments)
741 Res.push_back("-C");
742 if (Opts.ShowMacroComments)
743 Res.push_back("-CC");
744}
745
746static void TargetOptsToArgs(const TargetOptions &Opts,
747 std::vector<std::string> &Res) {
748 Res.push_back("-triple");
749 Res.push_back(Opts.Triple);
750 if (!Opts.CPU.empty()) {
Daniel Dunbar38b48af2009-12-18 06:30:12 +0000751 Res.push_back("-target-cpu");
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000752 Res.push_back(Opts.CPU);
753 }
754 if (!Opts.ABI.empty()) {
755 Res.push_back("-target-abi");
756 Res.push_back(Opts.ABI);
757 }
Daniel Dunbar39065a52010-08-11 23:07:42 +0000758 if (!Opts.LinkerVersion.empty()) {
759 Res.push_back("-target-linker-version");
760 Res.push_back(Opts.LinkerVersion);
761 }
John McCall875ab102010-08-22 06:43:33 +0000762 if (!Opts.CXXABI.empty()) {
763 Res.push_back("-cxx-abi");
764 Res.push_back(Opts.CXXABI);
765 }
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000766 for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) {
767 Res.push_back("-target-feature");
768 Res.push_back(Opts.Features[i]);
769 }
770}
771
772void CompilerInvocation::toArgs(std::vector<std::string> &Res) {
773 AnalyzerOptsToArgs(getAnalyzerOpts(), Res);
774 CodeGenOptsToArgs(getCodeGenOpts(), Res);
775 DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res);
776 DiagnosticOptsToArgs(getDiagnosticOpts(), Res);
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +0000777 FileSystemOptsToArgs(getFileSystemOpts(), Res);
Daniel Dunbarb3375cb2009-11-17 06:02:29 +0000778 FrontendOptsToArgs(getFrontendOpts(), Res);
779 HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res);
780 LangOptsToArgs(getLangOpts(), Res);
781 PreprocessorOptsToArgs(getPreprocessorOpts(), Res);
782 PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res);
783 TargetOptsToArgs(getTargetOpts(), Res);
784}
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000785
786//===----------------------------------------------------------------------===//
787// Deserialization (to args)
788//===----------------------------------------------------------------------===//
789
790using namespace clang::driver;
791using namespace clang::driver::cc1options;
792
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000793//
794
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +0000795static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
796 Diagnostic &Diags) {
Peter Collingbourne61e07862010-12-04 01:50:45 +0000797 unsigned DefaultOpt = 0;
798 if (IK == IK_OpenCL && !Args.hasArg(OPT_cl_opt_disable))
799 DefaultOpt = 2;
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +0000800 // -Os implies -O2
Peter Collingbourne61e07862010-12-04 01:50:45 +0000801 return Args.hasArg(OPT_Os) ? 2 :
802 Args.getLastArgIntValue(OPT_O, DefaultOpt, Diags);
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +0000803}
804
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000805static void ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
806 Diagnostic &Diags) {
807 using namespace cc1options;
808
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000809 if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
810 llvm::StringRef Name = A->getValue(Args);
811 AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
812#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
813 .Case(CMDFLAG, NAME##Model)
814#include "clang/Frontend/Analyses.def"
815 .Default(NumStores);
816 // FIXME: Error handling.
817 if (Value == NumStores)
818 Diags.Report(diag::err_drv_invalid_value)
Daniel Dunbarbfbb39d2010-06-09 22:30:54 +0000819 << A->getAsString(Args) << Name;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000820 else
821 Opts.AnalysisStoreOpt = Value;
822 }
823
824 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
825 llvm::StringRef Name = A->getValue(Args);
826 AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
827#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
828 .Case(CMDFLAG, NAME##Model)
829#include "clang/Frontend/Analyses.def"
830 .Default(NumConstraints);
831 // FIXME: Error handling.
832 if (Value == NumConstraints)
833 Diags.Report(diag::err_drv_invalid_value)
Daniel Dunbarbfbb39d2010-06-09 22:30:54 +0000834 << A->getAsString(Args) << Name;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000835 else
836 Opts.AnalysisConstraintsOpt = Value;
837 }
838
839 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
840 llvm::StringRef Name = A->getValue(Args);
841 AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
842#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
843 .Case(CMDFLAG, PD_##NAME)
844#include "clang/Frontend/Analyses.def"
845 .Default(NUM_ANALYSIS_DIAG_CLIENTS);
846 // FIXME: Error handling.
847 if (Value == NUM_ANALYSIS_DIAG_CLIENTS)
848 Diags.Report(diag::err_drv_invalid_value)
Daniel Dunbarbfbb39d2010-06-09 22:30:54 +0000849 << A->getAsString(Args) << Name;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000850 else
851 Opts.AnalysisDiagOpt = Value;
852 }
853
Argyrios Kyrtzidis116f3642011-02-25 00:09:51 +0000854 Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000855 Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
856 Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
857 Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
858 Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
Ted Kremenekfc576512009-12-07 22:06:12 +0000859 Opts.AnalyzeNestedBlocks =
860 Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000861 Opts.PurgeDead = !Args.hasArg(OPT_analyzer_no_purge_dead);
862 Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000863 Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
Ted Kremenek9b823e82010-08-03 00:09:51 +0000864 Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
Marcin Swiderski9121ba22010-09-30 07:41:24 +0000865 Opts.CFGAddImplicitDtors = Args.hasArg(OPT_analysis_CFGAddImplicitDtors);
866 Opts.CFGAddInitializers = Args.hasArg(OPT_analysis_CFGAddInitializers);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000867 Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000868 Opts.MaxNodes = Args.getLastArgIntValue(OPT_analyzer_max_nodes, 150000,Diags);
Ted Kremenek6648e5d2010-10-18 23:36:05 +0000869 Opts.MaxLoop = Args.getLastArgIntValue(OPT_analyzer_max_loop, 4, Diags);
Ted Kremenekd767d812011-02-09 01:27:33 +0000870 Opts.EagerlyTrimEGraph = !Args.hasArg(OPT_analyzer_no_eagerly_trim_egraph);
Zhongxing Xu7b99d122010-05-06 02:59:29 +0000871 Opts.InlineCall = Args.hasArg(OPT_analyzer_inline_call);
Argyrios Kyrtzidis43dee222011-02-14 18:13:31 +0000872
873 Opts.CheckersControlList.clear();
874 for (arg_iterator it = Args.filtered_begin(OPT_analyzer_checker,
875 OPT_analyzer_disable_checker),
876 ie = Args.filtered_end(); it != ie; ++it) {
877 const Arg *A = *it;
878 A->claim();
879 bool enable = (A->getOption().getID() == OPT_analyzer_checker);
Argyrios Kyrtzidis38c8fe72011-02-24 08:42:20 +0000880 // We can have a list of comma separated checker names, e.g:
881 // '-analyzer-checker=cocoa,unix'
882 llvm::StringRef checkerList = A->getValue(Args);
883 llvm::SmallVector<llvm::StringRef, 4> checkers;
884 checkerList.split(checkers, ",");
885 for (unsigned i = 0, e = checkers.size(); i != e; ++i)
886 Opts.CheckersControlList.push_back(std::make_pair(checkers[i], enable));
Argyrios Kyrtzidis43dee222011-02-14 18:13:31 +0000887 }
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000888}
889
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +0000890static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000891 Diagnostic &Diags) {
892 using namespace cc1options;
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +0000893
894 Opts.OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
895 if (Opts.OptimizationLevel > 3) {
896 Diags.Report(diag::err_drv_invalid_value)
897 << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel;
898 Opts.OptimizationLevel = 3;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000899 }
900
901 // We must always run at least the always inlining pass.
902 Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining
903 : CodeGenOptions::OnlyAlwaysInlining;
904
905 Opts.DebugInfo = Args.hasArg(OPT_g);
Devang Patelc69e1cf2010-09-30 19:05:55 +0000906 Opts.LimitDebugInfo = Args.hasArg(OPT_flimit_debug_info);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000907 Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
908 Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
John McCall32096692011-03-18 02:56:14 +0000909 Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
Dan Gohman4d5625e2010-10-14 22:36:56 +0000910 Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000911 Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000912 Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
913 Opts.NoCommon = Args.hasArg(OPT_fno_common);
914 Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
915 Opts.OptimizeSize = Args.hasArg(OPT_Os);
Daniel Dunbar6b0cf672010-06-07 23:19:17 +0000916 Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
917 Args.hasArg(OPT_ffreestanding));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000918 Opts.UnrollLoops = Args.hasArg(OPT_funroll_loops) ||
Eric Christopherf84d4092010-08-07 23:08:14 +0000919 (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000920
921 Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000922 Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
923 Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000924 Opts.CodeModel = Args.getLastArgValue(OPT_mcode_model);
925 Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000926 Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000927 Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
John McCall279b5eb2010-08-12 23:36:15 +0000928 Opts.HiddenWeakVTables = Args.hasArg(OPT_fhidden_weak_vtables);
Peter Collingbourne4400cb82010-12-04 01:51:33 +0000929 Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000930 Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
Peter Collingbournef0840822010-12-04 01:51:23 +0000931 Opts.NoInfsFPMath = Opts.NoNaNsFPMath = Args.hasArg(OPT_cl_finite_math_only)||
932 Args.hasArg(OPT_cl_fast_relaxed_math);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000933 Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
Daniel Dunbar3c66d302011-03-22 16:48:17 +0000934 Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
Daniel Dunbar17d3fea2011-02-09 17:54:19 +0000935 Opts.NumRegisterParameters = Args.getLastArgIntValue(OPT_mregparm, 0, Diags);
Daniel Dunbar4ecc9b72010-05-27 05:39:39 +0000936 Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
Daniel Dunbar1ad66482010-07-01 01:31:45 +0000937 Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000938 Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
Peter Collingbournef0840822010-12-04 01:51:23 +0000939 Opts.UnsafeFPMath = Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
940 Args.hasArg(OPT_cl_fast_relaxed_math);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000941 Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000942 Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000943
Chris Lattnerbbea7162010-04-13 00:38:24 +0000944 Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections);
945 Opts.DataSections = Args.hasArg(OPT_fdata_sections);
946
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000947 Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
John McCall824e19e2010-02-12 23:47:27 +0000948 Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
Daniel Dunbarf643b9b2010-04-24 17:56:46 +0000949
Chris Lattner7255a2d2010-06-22 00:03:40 +0000950 Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
Roman Divackybe4c8702011-02-10 16:52:03 +0000951 Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
Chris Lattner7255a2d2010-06-22 00:03:40 +0000952
Daniel Dunbarf643b9b2010-04-24 17:56:46 +0000953 if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
954 llvm::StringRef Name = A->getValue(Args);
955 unsigned Method = llvm::StringSwitch<unsigned>(Name)
956 .Case("legacy", CodeGenOptions::Legacy)
957 .Case("non-legacy", CodeGenOptions::NonLegacy)
958 .Case("mixed", CodeGenOptions::Mixed)
959 .Default(~0U);
960 if (Method == ~0U)
961 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
962 else
963 Opts.ObjCDispatchMethod = Method;
964 }
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000965}
966
967static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
968 ArgList &Args) {
969 using namespace cc1options;
Daniel Dunbar03e8ab22010-05-20 16:54:55 +0000970 Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
971 Opts.Targets = Args.getAllArgValues(OPT_MT);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000972 Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
973 Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
Daniel Dunbareef63e02011-02-02 15:41:17 +0000974 Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
Daniel Dunbarb34d69b2011-02-02 21:11:31 +0000975 Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +0000976}
977
978static void ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
979 Diagnostic &Diags) {
980 using namespace cc1options;
981 Opts.IgnoreWarnings = Args.hasArg(OPT_w);
982 Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
983 Opts.Pedantic = Args.hasArg(OPT_pedantic);
984 Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
985 Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
986 Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics);
987 Opts.ShowColumn = !Args.hasArg(OPT_fno_show_column);
988 Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
989 Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
990 Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
Jeffrey Yasskin5edbdcc2010-06-11 05:57:47 +0000991
992 llvm::StringRef ShowOverloads =
993 Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
994 if (ShowOverloads == "best")
995 Opts.ShowOverloads = Diagnostic::Ovl_Best;
996 else if (ShowOverloads == "all")
997 Opts.ShowOverloads = Diagnostic::Ovl_All;
998 else
999 Diags.Report(diag::err_drv_invalid_value)
1000 << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1001 << ShowOverloads;
1002
Chris Lattner6fbe8392010-05-04 21:55:25 +00001003 llvm::StringRef ShowCategory =
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001004 Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
Chris Lattner6fbe8392010-05-04 21:55:25 +00001005 if (ShowCategory == "none")
1006 Opts.ShowCategories = 0;
1007 else if (ShowCategory == "id")
1008 Opts.ShowCategories = 1;
1009 else if (ShowCategory == "name")
1010 Opts.ShowCategories = 2;
1011 else
1012 Diags.Report(diag::err_drv_invalid_value)
1013 << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1014 << ShowCategory;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001015
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001016 Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
Douglas Gregor4786c152010-08-19 20:24:43 +00001017 Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001018 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001019 Opts.ErrorLimit = Args.getLastArgIntValue(OPT_ferror_limit, 0, Diags);
Douglas Gregor6c1cb992010-05-04 17:13:42 +00001020 Opts.MacroBacktraceLimit
Michael J. Spencer20249a12010-10-21 03:16:25 +00001021 = Args.getLastArgIntValue(OPT_fmacro_backtrace_limit,
Douglas Gregor6c1cb992010-05-04 17:13:42 +00001022 DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
Douglas Gregor575cf372010-04-20 07:18:24 +00001023 Opts.TemplateBacktraceLimit
Michael J. Spencer20249a12010-10-21 03:16:25 +00001024 = Args.getLastArgIntValue(OPT_ftemplate_backtrace_limit,
1025 DiagnosticOptions::DefaultTemplateBacktraceLimit,
Douglas Gregor6c1cb992010-05-04 17:13:42 +00001026 Diags);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001027 Opts.TabStop = Args.getLastArgIntValue(OPT_ftabstop,
Chris Lattner52388f92010-01-13 03:06:50 +00001028 DiagnosticOptions::DefaultTabStop, Diags);
1029 if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1030 Diags.Report(diag::warn_ignoring_ftabstop_value)
1031 << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1032 Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1033 }
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001034 Opts.MessageLength = Args.getLastArgIntValue(OPT_fmessage_length, 0, Diags);
1035 Opts.DumpBuildInformation = Args.getLastArgValue(OPT_dump_build_information);
1036 Opts.Warnings = Args.getAllArgValues(OPT_W);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001037}
1038
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001039static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1040 Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1041}
1042
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001043static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1044 Diagnostic &Diags) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001045 using namespace cc1options;
1046 Opts.ProgramAction = frontend::ParseSyntaxOnly;
1047 if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1048 switch (A->getOption().getID()) {
1049 default:
1050 assert(0 && "Invalid option in group!");
1051 case OPT_ast_dump:
1052 Opts.ProgramAction = frontend::ASTDump; break;
John McCallf3514242010-11-24 11:21:45 +00001053 case OPT_ast_dump_xml:
1054 Opts.ProgramAction = frontend::ASTDumpXML; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001055 case OPT_ast_print:
1056 Opts.ProgramAction = frontend::ASTPrint; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001057 case OPT_ast_view:
1058 Opts.ProgramAction = frontend::ASTView; break;
Douglas Gregorf78cc432010-05-07 15:41:56 +00001059 case OPT_boostcon:
1060 Opts.ProgramAction = frontend::BoostCon; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001061 case OPT_dump_raw_tokens:
1062 Opts.ProgramAction = frontend::DumpRawTokens; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001063 case OPT_dump_tokens:
1064 Opts.ProgramAction = frontend::DumpTokens; break;
1065 case OPT_S:
1066 Opts.ProgramAction = frontend::EmitAssembly; break;
1067 case OPT_emit_llvm_bc:
1068 Opts.ProgramAction = frontend::EmitBC; break;
1069 case OPT_emit_html:
1070 Opts.ProgramAction = frontend::EmitHTML; break;
1071 case OPT_emit_llvm:
1072 Opts.ProgramAction = frontend::EmitLLVM; break;
1073 case OPT_emit_llvm_only:
1074 Opts.ProgramAction = frontend::EmitLLVMOnly; break;
Daniel Dunbar32148ce2010-05-25 18:41:01 +00001075 case OPT_emit_codegen_only:
1076 Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
Daniel Dunbarda1573f2010-02-03 01:18:43 +00001077 case OPT_emit_obj:
1078 Opts.ProgramAction = frontend::EmitObj; break;
Nick Lewyckyba5f6ec2010-04-24 01:30:46 +00001079 case OPT_fixit_EQ:
1080 Opts.FixItSuffix = A->getValue(Args);
1081 // fall-through!
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001082 case OPT_fixit:
1083 Opts.ProgramAction = frontend::FixIt; break;
1084 case OPT_emit_pch:
1085 Opts.ProgramAction = frontend::GeneratePCH; break;
1086 case OPT_emit_pth:
1087 Opts.ProgramAction = frontend::GeneratePTH; break;
Daniel Dunbar27585952010-03-19 19:44:04 +00001088 case OPT_init_only:
1089 Opts.ProgramAction = frontend::InitOnly; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001090 case OPT_fsyntax_only:
1091 Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
1092 case OPT_print_decl_contexts:
1093 Opts.ProgramAction = frontend::PrintDeclContext; break;
Douglas Gregorf033f1d2010-07-20 20:18:03 +00001094 case OPT_print_preamble:
1095 Opts.ProgramAction = frontend::PrintPreamble; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001096 case OPT_E:
1097 Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001098 case OPT_rewrite_macros:
1099 Opts.ProgramAction = frontend::RewriteMacros; break;
1100 case OPT_rewrite_objc:
1101 Opts.ProgramAction = frontend::RewriteObjC; break;
1102 case OPT_rewrite_test:
1103 Opts.ProgramAction = frontend::RewriteTest; break;
1104 case OPT_analyze:
1105 Opts.ProgramAction = frontend::RunAnalysis; break;
1106 case OPT_Eonly:
1107 Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
Sebastian Redle55fd872010-08-16 18:17:11 +00001108 case OPT_create_module:
1109 Opts.ProgramAction = frontend::CreateModule; break;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001110 }
1111 }
Daniel Dunbar3177aae2010-06-16 16:59:23 +00001112
1113 if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1114 Opts.Plugins.push_back(A->getValue(Args,0));
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001115 Opts.ProgramAction = frontend::PluginAction;
1116 Opts.ActionName = A->getValue(Args);
Daniel Dunbar3177aae2010-06-16 16:59:23 +00001117
1118 for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
1119 end = Args.filtered_end(); it != end; ++it) {
1120 if ((*it)->getValue(Args, 0) == Opts.ActionName)
1121 Opts.PluginArgs.push_back((*it)->getValue(Args, 1));
1122 }
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001123 }
1124
Nico Weber5aa74af2011-01-25 20:34:14 +00001125 Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
Nico Weberf25649c2011-01-29 21:21:49 +00001126 Opts.AddPluginArgs.resize(Opts.AddPluginActions.size());
1127 for (int i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
1128 for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
1129 end = Args.filtered_end(); it != end; ++it) {
1130 if ((*it)->getValue(Args, 0) == Opts.AddPluginActions[i])
1131 Opts.AddPluginArgs[i].push_back((*it)->getValue(Args, 1));
1132 }
1133 }
Nico Weber5aa74af2011-01-25 20:34:14 +00001134
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001135 if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1136 Opts.CodeCompletionAt =
1137 ParsedSourceLocation::FromString(A->getValue(Args));
1138 if (Opts.CodeCompletionAt.FileName.empty())
1139 Diags.Report(diag::err_drv_invalid_value)
1140 << A->getAsString(Args) << A->getValue(Args);
1141 }
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001142 Opts.DisableFree = Args.hasArg(OPT_disable_free);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001143
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001144 Opts.OutputFile = Args.getLastArgValue(OPT_o);
1145 Opts.Plugins = Args.getAllArgValues(OPT_load);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001146 Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
Sebastian Redld6ac4522010-07-09 00:00:58 +00001147 Opts.ChainedPCH = Args.hasArg(OPT_chained_pch);
Daniel Dunbar9b5e9ae2009-12-03 07:01:58 +00001148 Opts.ShowHelp = Args.hasArg(OPT_help);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001149 Opts.ShowMacrosInCodeCompletion = Args.hasArg(OPT_code_completion_macros);
Douglas Gregord8e8a582010-05-25 21:41:55 +00001150 Opts.ShowCodePatternsInCodeCompletion
1151 = Args.hasArg(OPT_code_completion_patterns);
Douglas Gregor8071e422010-08-15 06:18:01 +00001152 Opts.ShowGlobalSymbolsInCodeCompletion
1153 = !Args.hasArg(OPT_no_code_completion_globals);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001154 Opts.ShowStats = Args.hasArg(OPT_print_stats);
1155 Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
Daniel Dunbar9b5e9ae2009-12-03 07:01:58 +00001156 Opts.ShowVersion = Args.hasArg(OPT_version);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001157 Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1158 Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
Nick Lewycky1450f262010-08-13 17:31:00 +00001159 Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
Sebastian Redle55fd872010-08-16 18:17:11 +00001160 Opts.Modules = Args.getAllArgValues(OPT_import_module);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001161
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001162 InputKind DashX = IK_None;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001163 if (const Arg *A = Args.getLastArg(OPT_x)) {
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001164 DashX = llvm::StringSwitch<InputKind>(A->getValue(Args))
1165 .Case("c", IK_C)
1166 .Case("cl", IK_OpenCL)
1167 .Case("c", IK_C)
1168 .Case("cl", IK_OpenCL)
Peter Collingbourne895fcca2010-12-01 03:15:20 +00001169 .Case("cuda", IK_CUDA)
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001170 .Case("c++", IK_CXX)
1171 .Case("objective-c", IK_ObjC)
1172 .Case("objective-c++", IK_ObjCXX)
1173 .Case("cpp-output", IK_PreprocessedC)
1174 .Case("assembler-with-cpp", IK_Asm)
1175 .Case("c++-cpp-output", IK_PreprocessedCXX)
1176 .Case("objective-c-cpp-output", IK_PreprocessedObjC)
1177 .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX)
1178 .Case("c-header", IK_C)
1179 .Case("objective-c-header", IK_ObjC)
1180 .Case("c++-header", IK_CXX)
1181 .Case("objective-c++-header", IK_ObjCXX)
1182 .Case("ast", IK_AST)
Daniel Dunbarfaddc3e2010-06-07 23:26:47 +00001183 .Case("ir", IK_LLVM_IR)
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001184 .Default(IK_None);
1185 if (DashX == IK_None)
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001186 Diags.Report(diag::err_drv_invalid_value)
1187 << A->getAsString(Args) << A->getValue(Args);
1188 }
1189
1190 // '-' is the default input if none is given.
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001191 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001192 Opts.Inputs.clear();
1193 if (Inputs.empty())
1194 Inputs.push_back("-");
1195 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001196 InputKind IK = DashX;
1197 if (IK == IK_None) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001198 IK = FrontendOptions::getInputKindForExtension(
1199 llvm::StringRef(Inputs[i]).rsplit('.').second);
1200 // FIXME: Remove this hack.
1201 if (i == 0)
1202 DashX = IK;
1203 }
1204 Opts.Inputs.push_back(std::make_pair(IK, Inputs[i]));
1205 }
1206
1207 return DashX;
1208}
1209
Daniel Dunbar8b9adfe2009-12-15 00:06:45 +00001210std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1211 void *MainAddr) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001212 llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
1213
1214 if (!P.isEmpty()) {
1215 P.eraseComponent(); // Remove /clang from foo/bin/clang
1216 P.eraseComponent(); // Remove /bin from foo/bin
1217
1218 // Get foo/lib/clang/<version>/include
1219 P.appendComponent("lib");
1220 P.appendComponent("clang");
1221 P.appendComponent(CLANG_VERSION_STRING);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001222 }
1223
1224 return P.str();
1225}
1226
Daniel Dunbar1e69fe32009-12-13 03:45:58 +00001227static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001228 using namespace cc1options;
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001229 Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001230 Opts.Verbose = Args.hasArg(OPT_v);
Daniel Dunbar1e69fe32009-12-13 03:45:58 +00001231 Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001232 Opts.UseStandardIncludes = !Args.hasArg(OPT_nostdinc);
Douglas Gregor4c2bcad2010-03-24 20:13:48 +00001233 Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001234 Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001235
1236 // Add -I... and -F... options in order.
1237 for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F),
1238 ie = Args.filtered_end(); it != ie; ++it)
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001239 Opts.AddPath((*it)->getValue(Args), frontend::Angled, true,
Chris Lattner23637be2010-08-24 22:27:37 +00001240 /*IsFramework=*/ (*it)->getOption().matches(OPT_F), true);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001241
1242 // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1243 llvm::StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
1244 for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix,
1245 OPT_iwithprefixbefore),
1246 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001247 const Arg *A = *it;
1248 if (A->getOption().matches(OPT_iprefix))
1249 Prefix = A->getValue(Args);
1250 else if (A->getOption().matches(OPT_iwithprefix))
1251 Opts.AddPath(Prefix.str() + A->getValue(Args),
Chris Lattner23637be2010-08-24 22:27:37 +00001252 frontend::System, false, false, true);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001253 else
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001254 Opts.AddPath(Prefix.str() + A->getValue(Args),
Chris Lattner23637be2010-08-24 22:27:37 +00001255 frontend::Angled, false, false, true);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001256 }
1257
1258 for (arg_iterator it = Args.filtered_begin(OPT_idirafter),
1259 ie = Args.filtered_end(); it != ie; ++it)
Chris Lattner23637be2010-08-24 22:27:37 +00001260 Opts.AddPath((*it)->getValue(Args), frontend::After, true, false, true);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001261 for (arg_iterator it = Args.filtered_begin(OPT_iquote),
1262 ie = Args.filtered_end(); it != ie; ++it)
Chris Lattner23637be2010-08-24 22:27:37 +00001263 Opts.AddPath((*it)->getValue(Args), frontend::Quoted, true, false, true);
Joerg Sonnenberger2df66472011-02-22 00:40:56 +00001264 for (arg_iterator it = Args.filtered_begin(OPT_cxx_isystem, OPT_isystem,
1265 OPT_iwithsysroot), ie = Args.filtered_end(); it != ie; ++it)
1266 Opts.AddPath((*it)->getValue(Args),
1267 ((*it)->getOption().matches(OPT_cxx_isystem) ?
1268 frontend::CXXSystem : frontend::System),
1269 true, false, (*it)->getOption().matches(OPT_iwithsysroot));
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001270
1271 // FIXME: Need options for the various environment variables!
1272}
1273
Peter Collingbourne53c92be2010-12-04 01:50:27 +00001274void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
1275 LangStandard::Kind LangStd) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001276 // Set some properties which depend soley on the input kind; it would be nice
1277 // to move these to the language standard, and have the driver resolve the
1278 // input kind + language standard.
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001279 if (IK == IK_Asm) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001280 Opts.AsmPreprocessor = 1;
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001281 } else if (IK == IK_ObjC ||
1282 IK == IK_ObjCXX ||
1283 IK == IK_PreprocessedObjC ||
1284 IK == IK_PreprocessedObjCXX) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001285 Opts.ObjC1 = Opts.ObjC2 = 1;
1286 }
1287
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001288 if (LangStd == LangStandard::lang_unspecified) {
1289 // Based on the base language, pick one.
1290 switch (IK) {
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001291 case IK_None:
1292 case IK_AST:
Daniel Dunbarfaddc3e2010-06-07 23:26:47 +00001293 case IK_LLVM_IR:
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001294 assert(0 && "Invalid input kind!");
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001295 case IK_OpenCL:
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001296 LangStd = LangStandard::lang_opencl;
1297 break;
Peter Collingbourne895fcca2010-12-01 03:15:20 +00001298 case IK_CUDA:
1299 LangStd = LangStandard::lang_cuda;
1300 break;
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001301 case IK_Asm:
1302 case IK_C:
1303 case IK_PreprocessedC:
1304 case IK_ObjC:
1305 case IK_PreprocessedObjC:
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001306 LangStd = LangStandard::lang_gnu99;
1307 break;
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001308 case IK_CXX:
1309 case IK_PreprocessedCXX:
1310 case IK_ObjCXX:
1311 case IK_PreprocessedObjCXX:
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001312 LangStd = LangStandard::lang_gnucxx98;
1313 break;
1314 }
1315 }
1316
1317 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1318 Opts.BCPLComment = Std.hasBCPLComments();
1319 Opts.C99 = Std.isC99();
1320 Opts.CPlusPlus = Std.isCPlusPlus();
1321 Opts.CPlusPlus0x = Std.isCPlusPlus0x();
1322 Opts.Digraphs = Std.hasDigraphs();
1323 Opts.GNUMode = Std.isGNUMode();
1324 Opts.GNUInline = !Std.isC99();
1325 Opts.HexFloats = Std.hasHexFloats();
1326 Opts.ImplicitInt = Std.hasImplicitInt();
1327
1328 // OpenCL has some additional defaults.
1329 if (LangStd == LangStandard::lang_opencl) {
1330 Opts.OpenCL = 1;
1331 Opts.AltiVec = 1;
1332 Opts.CXXOperatorNames = 1;
1333 Opts.LaxVectorConversions = 1;
Peter Collingbournef315fa82011-02-14 01:42:53 +00001334 Opts.DefaultFPContract = 1;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001335 }
1336
Peter Collingbourne895fcca2010-12-01 03:15:20 +00001337 if (LangStd == LangStandard::lang_cuda)
1338 Opts.CUDA = 1;
1339
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001340 // OpenCL and C++ both have bool, true, false keywords.
1341 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1342
Peter Collingbourne53c92be2010-12-04 01:50:27 +00001343 Opts.GNUKeywords = Opts.GNUMode;
1344 Opts.CXXOperatorNames = Opts.CPlusPlus;
1345
1346 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1347 // is specified, or -std is set to a conforming mode.
1348 Opts.Trigraphs = !Opts.GNUMode;
1349
1350 Opts.DollarIdents = !Opts.AsmPreprocessor;
1351}
1352
1353static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
1354 Diagnostic &Diags) {
1355 // FIXME: Cleanup per-file based stuff.
1356 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
1357 if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
1358 LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
1359#define LANGSTANDARD(id, name, desc, features) \
1360 .Case(name, LangStandard::lang_##id)
1361#include "clang/Frontend/LangStandards.def"
1362 .Default(LangStandard::lang_unspecified);
1363 if (LangStd == LangStandard::lang_unspecified)
1364 Diags.Report(diag::err_drv_invalid_value)
1365 << A->getAsString(Args) << A->getValue(Args);
1366 }
1367
Peter Collingbourne91252d12010-12-04 01:51:40 +00001368 if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
1369 if (strcmp(A->getValue(Args), "CL1.1") != 0) {
1370 Diags.Report(diag::err_drv_invalid_value)
1371 << A->getAsString(Args) << A->getValue(Args);
1372 }
1373 }
1374
Peter Collingbourne53c92be2010-12-04 01:50:27 +00001375 CompilerInvocation::setLangDefaults(Opts, IK, LangStd);
1376
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00001377 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1378 // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1379 // while a subset (the non-C++ GNU keywords) is provided by GCC's
1380 // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1381 // name, as it doesn't seem a useful distinction.
1382 Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
Peter Collingbourne53c92be2010-12-04 01:50:27 +00001383 Opts.GNUKeywords);
Chandler Carrutheb5d7b72010-04-17 20:17:31 +00001384
Peter Collingbourne53c92be2010-12-04 01:50:27 +00001385 if (Args.hasArg(OPT_fno_operator_names))
1386 Opts.CXXOperatorNames = 0;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001387
1388 if (Args.hasArg(OPT_fobjc_gc_only))
1389 Opts.setGCMode(LangOptions::GCOnly);
1390 else if (Args.hasArg(OPT_fobjc_gc))
1391 Opts.setGCMode(LangOptions::HybridGC);
Fariborz Jahanianb466d012011-01-07 01:05:02 +00001392
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001393 if (Args.hasArg(OPT_fapple_kext)) {
1394 if (!Opts.CPlusPlus)
1395 Diags.Report(diag::warn_c_kext);
1396 else
1397 Opts.AppleKext = 1;
1398 }
1399
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001400 if (Args.hasArg(OPT_print_ivar_layout))
1401 Opts.ObjCGCBitmapPrint = 1;
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001402 if (Args.hasArg(OPT_fno_constant_cfstrings))
1403 Opts.NoConstantCFStrings = 1;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001404
1405 if (Args.hasArg(OPT_faltivec))
1406 Opts.AltiVec = 1;
1407
1408 if (Args.hasArg(OPT_pthread))
1409 Opts.POSIXThreads = 1;
1410
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001411 llvm::StringRef Vis = Args.getLastArgValue(OPT_fvisibility, "default");
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001412 if (Vis == "default")
John McCall1fb0caa2010-10-22 21:05:15 +00001413 Opts.setVisibilityMode(DefaultVisibility);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001414 else if (Vis == "hidden")
John McCall1fb0caa2010-10-22 21:05:15 +00001415 Opts.setVisibilityMode(HiddenVisibility);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001416 else if (Vis == "protected")
John McCall1fb0caa2010-10-22 21:05:15 +00001417 Opts.setVisibilityMode(ProtectedVisibility);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001418 else
1419 Diags.Report(diag::err_drv_invalid_value)
1420 << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
1421
Douglas Gregor7cf84d62010-06-15 17:05:35 +00001422 if (Args.hasArg(OPT_fvisibility_inlines_hidden))
1423 Opts.InlineVisibilityHidden = 1;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001424
David Chisnall7f18e672010-09-17 18:29:54 +00001425 if (Args.hasArg(OPT_ftrapv)) {
Michael J. Spencer20249a12010-10-21 03:16:25 +00001426 Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
David Chisnall7f18e672010-09-17 18:29:54 +00001427 // Set the handler, if one is specified.
1428 Opts.OverflowHandler =
1429 Args.getLastArgValue(OPT_ftrapv_handler);
1430 }
Chris Lattnera4d71452010-06-26 21:25:03 +00001431 else if (Args.hasArg(OPT_fwrapv))
Michael J. Spencer20249a12010-10-21 03:16:25 +00001432 Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001433
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001434 if (Args.hasArg(OPT_trigraphs))
1435 Opts.Trigraphs = 1;
1436
Daniel Dunbar8663b182009-12-16 20:10:18 +00001437 Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
1438 OPT_fno_dollars_in_identifiers,
Peter Collingbourne53c92be2010-12-04 01:50:27 +00001439 Opts.DollarIdents);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001440 Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
1441 Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00001442 Opts.MSCVersion = Args.getLastArgIntValue(OPT_fmsc_version, 0, Diags);
Dawn Perchik400b6072010-09-02 23:59:25 +00001443 Opts.Borland = Args.hasArg(OPT_fborland_extensions);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001444 Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
John McCall4b7a8342010-03-15 10:54:44 +00001445 Opts.ConstStrings = Args.hasArg(OPT_Wwrite_strings);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001446 if (Args.hasArg(OPT_fno_lax_vector_conversions))
Anders Carlssona508b7d2010-02-06 23:23:06 +00001447 Opts.LaxVectorConversions = 0;
1448 if (Args.hasArg(OPT_fno_threadsafe_statics))
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001449 Opts.ThreadsafeStatics = 0;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001450 Opts.Exceptions = Args.hasArg(OPT_fexceptions);
Anders Carlssone9b801f2011-02-22 01:52:06 +00001451 Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
Anders Carlsson0761e442011-02-23 03:16:42 +00001452 Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
1453 Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
Daniel Dunbar2ed42282011-03-18 21:23:38 +00001454 Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
Anders Carlsson0761e442011-02-23 03:16:42 +00001455
Mike Stumpde050572009-12-02 18:57:08 +00001456 Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001457 Opts.Blocks = Args.hasArg(OPT_fblocks);
1458 Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
1459 Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
Argyrios Kyrtzidis9a2b9d72010-10-08 00:25:19 +00001460 Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001461 Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
1462 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
Nuno Lopesfc284482009-12-16 16:59:22 +00001463 Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001464 Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
John McCall7002f4c2010-04-09 19:03:51 +00001465 Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001466 Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
Dan Gohmanc31176d2010-01-08 02:20:44 +00001467 Opts.MathErrno = Args.hasArg(OPT_fmath_errno);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001468 Opts.InstantiationDepth = Args.getLastArgIntValue(OPT_ftemplate_depth, 1024,
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001469 Diags);
Argyrios Kyrtzidis1380a142010-11-18 00:20:36 +00001470 Opts.NumLargeByValueCopy = Args.getLastArgIntValue(OPT_Wlarge_by_value_copy,
Argyrios Kyrtzidis3532fdd2010-11-17 23:11:54 +00001471 0, Diags);
Douglas Gregor6f755502011-02-01 15:15:22 +00001472 Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001473 Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001474 Opts.ObjCConstantStringClass =
1475 Args.getLastArgValue(OPT_fconstant_string_class);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001476 Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
Fariborz Jahanian112c3302011-01-04 20:05:20 +00001477 if (Opts.ObjCNonFragileABI)
1478 Opts.ObjCNonFragileABI2 = true;
Ted Kremenekc32647d2010-12-23 21:35:43 +00001479 Opts.ObjCDefaultSynthProperties =
1480 Args.hasArg(OPT_fobjc_default_synthesize_properties);
Mike Stump9c276ae2009-12-12 01:27:46 +00001481 Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001482 Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001483 Opts.PICLevel = Args.getLastArgIntValue(OPT_pic_level, 0, Diags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001484 Opts.Static = Args.hasArg(OPT_static_define);
Anders Carlsson46116ce2010-04-10 19:09:13 +00001485 Opts.DumpRecordLayouts = Args.hasArg(OPT_fdump_record_layouts);
Anders Carlsson046c2942010-04-17 20:15:18 +00001486 Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
Douglas Gregora0068fc2010-07-09 17:35:33 +00001487 Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
Daniel Dunbarfb937b82010-04-15 15:06:22 +00001488 Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
Peter Collingbourne09821362010-12-04 01:50:56 +00001489 Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
Peter Collingbournef0840822010-12-04 01:51:23 +00001490 Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001491 Opts.OptimizeSize = 0;
Roman Divackycfe9af22011-03-01 17:40:53 +00001492 Opts.MRTD = Args.hasArg(OPT_mrtd);
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001493 Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001494
1495 // FIXME: Eliminate this dependency.
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +00001496 unsigned Opt = getOptimizationLevel(Args, IK, Diags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001497 Opts.Optimize = Opt != 0;
1498
1499 // This is the __NO_INLINE__ define, which just depends on things like the
1500 // optimization level and -fno-inline, not actually whether the backend has
1501 // inlining enabled.
1502 //
1503 // FIXME: This is affected by other options (-fno-inline).
1504 Opts.NoInline = !Opt;
1505
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001506 unsigned SSP = Args.getLastArgIntValue(OPT_stack_protector, 0, Diags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001507 switch (SSP) {
1508 default:
1509 Diags.Report(diag::err_drv_invalid_value)
1510 << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
1511 break;
1512 case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
1513 case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break;
1514 case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
1515 }
1516}
1517
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001518static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001519 FileManager &FileMgr,
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001520 Diagnostic &Diags) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001521 using namespace cc1options;
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001522 Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
1523 Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001524 if (const Arg *A = Args.getLastArg(OPT_token_cache))
1525 Opts.TokenCache = A->getValue(Args);
1526 else
1527 Opts.TokenCache = Opts.ImplicitPTHInclude;
1528 Opts.UsePredefines = !Args.hasArg(OPT_undef);
Douglas Gregor94dc8f62010-03-19 16:15:56 +00001529 Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001530 Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
Argyrios Kyrtzidis3e785932010-10-14 20:14:25 +00001531
Argyrios Kyrtzidisb9728582010-10-14 20:14:18 +00001532 Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
Argyrios Kyrtzidis3e785932010-10-14 20:14:25 +00001533 for (arg_iterator it = Args.filtered_begin(OPT_error_on_deserialized_pch_decl),
1534 ie = Args.filtered_end(); it != ie; ++it) {
1535 const Arg *A = *it;
1536 Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue(Args));
1537 }
Douglas Gregorfae3b2f2010-07-27 00:27:13 +00001538
Douglas Gregorf4f6c9d2010-07-26 21:36:20 +00001539 if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
1540 llvm::StringRef Value(A->getValue(Args));
1541 size_t Comma = Value.find(',');
1542 unsigned Bytes = 0;
1543 unsigned EndOfLine = 0;
Michael J. Spencer20249a12010-10-21 03:16:25 +00001544
Douglas Gregorf4f6c9d2010-07-26 21:36:20 +00001545 if (Comma == llvm::StringRef::npos ||
1546 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
1547 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
1548 Diags.Report(diag::err_drv_preamble_format);
1549 else {
1550 Opts.PrecompiledPreambleBytes.first = Bytes;
1551 Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
1552 }
1553 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00001554
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001555 // Add macros from the command line.
1556 for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
1557 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001558 if ((*it)->getOption().matches(OPT_D))
1559 Opts.addMacroDef((*it)->getValue(Args));
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001560 else
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001561 Opts.addMacroUndef((*it)->getValue(Args));
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001562 }
1563
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001564 Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001565
1566 // Add the ordered list of -includes.
1567 for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
1568 OPT_include_pth),
1569 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001570 const Arg *A = *it;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001571 // PCH is handled specially, we need to extra the original include path.
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001572 if (A->getOption().matches(OPT_include_pch)) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001573 std::string OriginalFile =
Chris Lattner39b49bc2010-11-23 08:35:12 +00001574 ASTReader::getOriginalSourceFile(A->getValue(Args), FileMgr, Diags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001575 if (OriginalFile.empty())
Daniel Dunbar93ebb1b2009-12-03 09:13:06 +00001576 continue;
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001577
1578 Opts.Includes.push_back(OriginalFile);
1579 } else
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001580 Opts.Includes.push_back(A->getValue(Args));
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001581 }
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001582
Argyrios Kyrtzidisb0f4b9a2011-03-09 17:21:42 +00001583 for (arg_iterator it = Args.filtered_begin(OPT_chain_include),
1584 ie = Args.filtered_end(); it != ie; ++it) {
1585 const Arg *A = *it;
1586 Opts.ChainedIncludes.push_back(A->getValue(Args));
1587 }
1588
Chris Lattnerdd173942010-04-14 03:54:58 +00001589 // Include 'altivec.h' if -faltivec option present
1590 if (Args.hasArg(OPT_faltivec))
1591 Opts.Includes.push_back("altivec.h");
1592
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001593 for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
1594 ie = Args.filtered_end(); it != ie; ++it) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001595 const Arg *A = *it;
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001596 std::pair<llvm::StringRef,llvm::StringRef> Split =
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001597 llvm::StringRef(A->getValue(Args)).split(';');
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001598
1599 if (Split.second.empty()) {
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001600 Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
Daniel Dunbare14b5f52009-12-03 05:11:16 +00001601 continue;
1602 }
1603
1604 Opts.addRemappedFile(Split.first, Split.second);
1605 }
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001606}
1607
1608static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
1609 ArgList &Args) {
1610 using namespace cc1options;
1611 Opts.ShowCPP = !Args.hasArg(OPT_dM);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001612 Opts.ShowComments = Args.hasArg(OPT_C);
Daniel Dunbarf7c16d92010-08-24 22:44:13 +00001613 Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001614 Opts.ShowMacroComments = Args.hasArg(OPT_CC);
Daniel Dunbarf7c16d92010-08-24 22:44:13 +00001615 Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001616}
1617
1618static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
1619 using namespace cc1options;
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001620 Opts.ABI = Args.getLastArgValue(OPT_target_abi);
Charles Davis98b7c5c2010-06-11 01:06:47 +00001621 Opts.CXXABI = Args.getLastArgValue(OPT_cxx_abi);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001622 Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
Daniel Dunbar03e8ab22010-05-20 16:54:55 +00001623 Opts.Features = Args.getAllArgValues(OPT_target_feature);
Daniel Dunbar39065a52010-08-11 23:07:42 +00001624 Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
Duncan Sands2dc14532010-08-30 09:42:39 +00001625 Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001626
1627 // Use the host triple if unspecified.
1628 if (Opts.Triple.empty())
1629 Opts.Triple = llvm::sys::getHostTriple();
1630}
1631
1632//
1633
1634void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
Chris Lattner39b49bc2010-11-23 08:35:12 +00001635 const char *const *ArgBegin,
1636 const char *const *ArgEnd,
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001637 Diagnostic &Diags) {
1638 // Parse the arguments.
1639 llvm::OwningPtr<OptTable> Opts(createCC1OptTable());
1640 unsigned MissingArgIndex, MissingArgCount;
1641 llvm::OwningPtr<InputArgList> Args(
1642 Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount));
1643
1644 // Check for missing argument error.
1645 if (MissingArgCount)
1646 Diags.Report(diag::err_drv_missing_argument)
1647 << Args->getArgString(MissingArgIndex) << MissingArgCount;
1648
1649 // Issue errors on unknown arguments.
1650 for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
1651 ie = Args->filtered_end(); it != ie; ++it)
Daniel Dunbar7e4953e2010-06-11 22:00:13 +00001652 Diags.Report(diag::err_drv_unknown_argument) << (*it)->getAsString(*Args);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001653
1654 ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001655 ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args);
1656 ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags);
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001657 ParseFileSystemArgs(Res.getFileSystemOpts(), *Args);
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +00001658 // FIXME: We shouldn't have to pass the DashX option around here
Daniel Dunbarc34ce3f2010-06-07 23:22:09 +00001659 InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags);
Peter Collingbourne0a3c03c2010-12-04 01:50:36 +00001660 ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, DashX, Diags);
Daniel Dunbar1e69fe32009-12-13 03:45:58 +00001661 ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args);
Fariborz Jahaniane293d302011-02-25 17:24:55 +00001662 if (DashX != IK_AST && DashX != IK_LLVM_IR) {
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001663 ParseLangArgs(Res.getLangOpts(), *Args, DashX, Diags);
Fariborz Jahaniane293d302011-02-25 17:24:55 +00001664 if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
1665 Res.getLangOpts().ObjCExceptions = 1;
1666 }
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001667 // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
1668 // PCH file and find the original header name. Remove the need to do that in
Chris Lattner39b49bc2010-11-23 08:35:12 +00001669 // ParsePreprocessorArgs and remove the FileManager
Argyrios Kyrtzidis389db162010-11-03 22:45:23 +00001670 // parameters from the function and the "FileManager.h" #include.
Chris Lattner7ad97ff2010-11-23 07:51:02 +00001671 FileManager FileMgr(Res.getFileSystemOpts());
Chris Lattner39b49bc2010-11-23 08:35:12 +00001672 ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, FileMgr, Diags);
Daniel Dunbar56ac85c2009-12-01 03:16:53 +00001673 ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args);
1674 ParseTargetArgs(Res.getTargetOpts(), *Args);
1675}