1 //===--- CompilerInvocation.cpp -------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/Frontend/CompilerInvocation.h"
11 #include "clang/Basic/Diagnostic.h"
12 #include "clang/Basic/Version.h"
13 #include "clang/Basic/FileManager.h"
14 #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"
22 #include "clang/Serialization/ASTReader.h"
23 #include "llvm/ADT/OwningPtr.h"
24 #include "llvm/ADT/SmallVector.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/ADT/StringSwitch.h"
27 #include "llvm/ADT/Triple.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/Host.h"
30 #include "llvm/Support/Path.h"
31 using namespace clang
;
33 static const char *getAnalysisStoreName(AnalysisStores Kind
) {
36 llvm_unreachable("Unknown analysis store!");
37 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
38 case NAME##Model: return CMDFLAG;
39 #include "clang/Frontend/Analyses.def"
43 static const char *getAnalysisConstraintName(AnalysisConstraints Kind
) {
46 llvm_unreachable("Unknown analysis constraints!");
47 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
48 case NAME##Model: return CMDFLAG;
49 #include "clang/Frontend/Analyses.def"
53 static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind
) {
56 llvm_unreachable("Unknown analysis client!");
57 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
58 case PD_##NAME: return CMDFLAG;
59 #include "clang/Frontend/Analyses.def"
63 //===----------------------------------------------------------------------===//
64 // Serialization (to args)
65 //===----------------------------------------------------------------------===//
67 static void AnalyzerOptsToArgs(const AnalyzerOptions
&Opts
,
68 std::vector
<std::string
> &Res
) {
69 if (Opts
.ShowCheckerHelp
)
70 Res
.push_back("-analyzer-checker-help");
71 if (Opts
.AnalysisStoreOpt
!= BasicStoreModel
) {
72 Res
.push_back("-analyzer-store");
73 Res
.push_back(getAnalysisStoreName(Opts
.AnalysisStoreOpt
));
75 if (Opts
.AnalysisConstraintsOpt
!= RangeConstraintsModel
) {
76 Res
.push_back("-analyzer-constraints");
77 Res
.push_back(getAnalysisConstraintName(Opts
.AnalysisConstraintsOpt
));
79 if (Opts
.AnalysisDiagOpt
!= PD_HTML
) {
80 Res
.push_back("-analyzer-output");
81 Res
.push_back(getAnalysisDiagClientName(Opts
.AnalysisDiagOpt
));
83 if (!Opts
.AnalyzeSpecificFunction
.empty()) {
84 Res
.push_back("-analyze-function");
85 Res
.push_back(Opts
.AnalyzeSpecificFunction
);
88 Res
.push_back("-analyzer-opt-analyze-headers");
89 if (Opts
.AnalyzerDisplayProgress
)
90 Res
.push_back("-analyzer-display-progress");
91 if (Opts
.AnalyzeNestedBlocks
)
92 Res
.push_back("-analyzer-opt-analyze-nested-blocks");
93 if (Opts
.EagerlyAssume
)
94 Res
.push_back("-analyzer-eagerly-assume");
96 Res
.push_back("-analyzer-no-purge-dead");
98 Res
.push_back("-trim-egraph");
99 if (Opts
.VisualizeEGDot
)
100 Res
.push_back("-analyzer-viz-egraph-graphviz");
101 if (Opts
.VisualizeEGUbi
)
102 Res
.push_back("-analyzer-viz-egraph-ubigraph");
104 for (unsigned i
= 0, e
= Opts
.CheckersControlList
.size(); i
!= e
; ++i
) {
105 const std::pair
<std::string
, bool> &opt
= Opts
.CheckersControlList
[i
];
107 Res
.push_back("-analyzer-disable-checker");
109 Res
.push_back("-analyzer-checker");
110 Res
.push_back(opt
.first
);
114 static void CodeGenOptsToArgs(const CodeGenOptions
&Opts
,
115 std::vector
<std::string
> &Res
) {
118 if (Opts
.DisableLLVMOpts
)
119 Res
.push_back("-disable-llvm-optzns");
120 if (Opts
.DisableRedZone
)
121 Res
.push_back("-disable-red-zone");
122 if (!Opts
.DwarfDebugFlags
.empty()) {
123 Res
.push_back("-dwarf-debug-flags");
124 Res
.push_back(Opts
.DwarfDebugFlags
);
126 if (Opts
.ObjCRuntimeHasARC
)
127 Res
.push_back("-fobjc-runtime-has-arc");
128 if (Opts
.ObjCRuntimeHasTerminate
)
129 Res
.push_back("-fobjc-runtime-has-terminate");
130 if (Opts
.EmitGcovArcs
)
131 Res
.push_back("-femit-coverage-data");
132 if (Opts
.EmitGcovNotes
)
133 Res
.push_back("-femit-coverage-notes");
134 if (!Opts
.MergeAllConstants
)
135 Res
.push_back("-fno-merge-all-constants");
137 Res
.push_back("-fno-common");
138 if (Opts
.ForbidGuardVariables
)
139 Res
.push_back("-fforbid-guard-variables");
140 if (Opts
.UseRegisterSizedBitfieldAccess
)
141 Res
.push_back("-fuse-register-sized-bitfield-access");
142 if (Opts
.NoImplicitFloat
)
143 Res
.push_back("-no-implicit-float");
144 if (Opts
.OmitLeafFramePointer
)
145 Res
.push_back("-momit-leaf-frame-pointer");
146 if (Opts
.OptimizeSize
) {
147 assert(Opts
.OptimizationLevel
== 2 && "Invalid options!");
148 Opts
.OptimizeSize
== 1 ? Res
.push_back("-Os") : Res
.push_back("-Oz");
149 } else if (Opts
.OptimizationLevel
!= 0)
150 Res
.push_back("-O" + llvm::utostr(Opts
.OptimizationLevel
));
151 if (!Opts
.MainFileName
.empty()) {
152 Res
.push_back("-main-file-name");
153 Res
.push_back(Opts
.MainFileName
);
155 // SimplifyLibCalls is only derived.
156 // TimePasses is only derived.
157 // UnitAtATime is unused.
158 // Inlining is only derived.
160 // UnrollLoops is derived, but also accepts an option, no
161 // harm in pushing it back here.
162 if (Opts
.UnrollLoops
)
163 Res
.push_back("-funroll-loops");
164 if (Opts
.DataSections
)
165 Res
.push_back("-fdata-sections");
166 if (Opts
.FunctionSections
)
167 Res
.push_back("-ffunction-sections");
169 Res
.push_back("-masm-verbose");
170 if (!Opts
.CodeModel
.empty()) {
171 Res
.push_back("-mcode-model");
172 Res
.push_back(Opts
.CodeModel
);
175 Res
.push_back("-fno-use-cxa-atexit");
176 if (Opts
.CXXCtorDtorAliases
)
177 Res
.push_back("-mconstructor-aliases");
178 if (Opts
.ObjCAutoRefCountExceptions
)
179 Res
.push_back("-fobjc-arc-eh");
180 if (!Opts
.DebugPass
.empty()) {
181 Res
.push_back("-mdebug-pass");
182 Res
.push_back(Opts
.DebugPass
);
184 if (Opts
.DisableFPElim
)
185 Res
.push_back("-mdisable-fp-elim");
186 if (!Opts
.FloatABI
.empty()) {
187 Res
.push_back("-mfloat-abi");
188 Res
.push_back(Opts
.FloatABI
);
190 if (!Opts
.LimitFloatPrecision
.empty()) {
191 Res
.push_back("-mlimit-float-precision");
192 Res
.push_back(Opts
.LimitFloatPrecision
);
194 if (Opts
.NoZeroInitializedInBSS
)
195 Res
.push_back("-mno-zero-initialized-bss");
196 switch (Opts
.getObjCDispatchMethod()) {
197 case CodeGenOptions::Legacy
:
199 case CodeGenOptions::Mixed
:
200 Res
.push_back("-fobjc-dispatch-method=mixed");
202 case CodeGenOptions::NonLegacy
:
203 Res
.push_back("-fobjc-dispatch-method=non-legacy");
206 if (Opts
.NumRegisterParameters
) {
207 Res
.push_back("-mregparm");
208 Res
.push_back(llvm::utostr(Opts
.NumRegisterParameters
));
210 if (Opts
.NoExecStack
)
211 Res
.push_back("-mnoexecstack");
213 Res
.push_back("-mrelax-all");
214 if (Opts
.SaveTempLabels
)
215 Res
.push_back("-msave-temp-labels");
216 if (Opts
.NoDwarf2CFIAsm
)
217 Res
.push_back("-fno-dwarf2-cfi-asm");
219 Res
.push_back("-msoft-float");
220 if (Opts
.UnwindTables
)
221 Res
.push_back("-munwind-tables");
222 if (Opts
.RelocationModel
!= "pic") {
223 Res
.push_back("-mrelocation-model");
224 Res
.push_back(Opts
.RelocationModel
);
226 if (!Opts
.VerifyModule
)
227 Res
.push_back("-disable-llvm-verifier");
228 for (unsigned i
= 0, e
= Opts
.BackendOptions
.size(); i
!= e
; ++i
) {
229 Res
.push_back("-backend-option");
230 Res
.push_back(Opts
.BackendOptions
[i
]);
234 static void DependencyOutputOptsToArgs(const DependencyOutputOptions
&Opts
,
235 std::vector
<std::string
> &Res
) {
236 if (Opts
.IncludeSystemHeaders
)
237 Res
.push_back("-sys-header-deps");
238 if (Opts
.ShowHeaderIncludes
)
240 if (!Opts
.HeaderIncludeOutputFile
.empty()) {
241 Res
.push_back("-header-include-file");
242 Res
.push_back(Opts
.HeaderIncludeOutputFile
);
244 if (Opts
.UsePhonyTargets
)
245 Res
.push_back("-MP");
246 if (!Opts
.OutputFile
.empty()) {
247 Res
.push_back("-dependency-file");
248 Res
.push_back(Opts
.OutputFile
);
250 for (unsigned i
= 0, e
= Opts
.Targets
.size(); i
!= e
; ++i
) {
251 Res
.push_back("-MT");
252 Res
.push_back(Opts
.Targets
[i
]);
256 static void DiagnosticOptsToArgs(const DiagnosticOptions
&Opts
,
257 std::vector
<std::string
> &Res
) {
258 if (Opts
.IgnoreWarnings
)
260 if (Opts
.NoRewriteMacros
)
261 Res
.push_back("-Wno-rewrite-macros");
263 Res
.push_back("-pedantic");
264 if (Opts
.PedanticErrors
)
265 Res
.push_back("-pedantic-errors");
266 if (!Opts
.ShowColumn
)
267 Res
.push_back("-fno-show-column");
268 if (!Opts
.ShowLocation
)
269 Res
.push_back("-fno-show-source-location");
270 if (!Opts
.ShowCarets
)
271 Res
.push_back("-fno-caret-diagnostics");
272 if (!Opts
.ShowFixits
)
273 Res
.push_back("-fno-diagnostics-fixit-info");
274 if (Opts
.ShowSourceRanges
)
275 Res
.push_back("-fdiagnostics-print-source-range-info");
276 if (Opts
.ShowParseableFixits
)
277 Res
.push_back("-fdiagnostics-parseable-fixits");
279 Res
.push_back("-fcolor-diagnostics");
280 if (Opts
.VerifyDiagnostics
)
281 Res
.push_back("-verify");
283 Res
.push_back("-fdiagnostics-show-name");
284 if (Opts
.ShowOptionNames
)
285 Res
.push_back("-fdiagnostics-show-option");
286 if (Opts
.ShowCategories
== 1)
287 Res
.push_back("-fdiagnostics-show-category=id");
288 else if (Opts
.ShowCategories
== 2)
289 Res
.push_back("-fdiagnostics-show-category=name");
290 switch (Opts
.Format
) {
291 case DiagnosticOptions::Clang
:
292 Res
.push_back("-fdiagnostics-format=clang"); break;
293 case DiagnosticOptions::Msvc
:
294 Res
.push_back("-fdiagnostics-format=msvc"); break;
295 case DiagnosticOptions::Vi
:
296 Res
.push_back("-fdiagnostics-format=vi"); break;
298 if (Opts
.ErrorLimit
) {
299 Res
.push_back("-ferror-limit");
300 Res
.push_back(llvm::utostr(Opts
.ErrorLimit
));
302 if (!Opts
.DiagnosticLogFile
.empty()) {
303 Res
.push_back("-diagnostic-log-file");
304 Res
.push_back(Opts
.DiagnosticLogFile
);
306 if (Opts
.MacroBacktraceLimit
307 != DiagnosticOptions::DefaultMacroBacktraceLimit
) {
308 Res
.push_back("-fmacro-backtrace-limit");
309 Res
.push_back(llvm::utostr(Opts
.MacroBacktraceLimit
));
311 if (Opts
.TemplateBacktraceLimit
312 != DiagnosticOptions::DefaultTemplateBacktraceLimit
) {
313 Res
.push_back("-ftemplate-backtrace-limit");
314 Res
.push_back(llvm::utostr(Opts
.TemplateBacktraceLimit
));
317 if (Opts
.TabStop
!= DiagnosticOptions::DefaultTabStop
) {
318 Res
.push_back("-ftabstop");
319 Res
.push_back(llvm::utostr(Opts
.TabStop
));
321 if (Opts
.MessageLength
) {
322 Res
.push_back("-fmessage-length");
323 Res
.push_back(llvm::utostr(Opts
.MessageLength
));
325 if (!Opts
.DumpBuildInformation
.empty()) {
326 Res
.push_back("-dump-build-information");
327 Res
.push_back(Opts
.DumpBuildInformation
);
329 for (unsigned i
= 0, e
= Opts
.Warnings
.size(); i
!= e
; ++i
)
330 Res
.push_back("-W" + Opts
.Warnings
[i
]);
333 static const char *getInputKindName(InputKind Kind
) {
336 case IK_AST
: return "ast";
337 case IK_Asm
: return "assembler-with-cpp";
338 case IK_C
: return "c";
339 case IK_CXX
: return "c++";
340 case IK_LLVM_IR
: return "ir";
341 case IK_ObjC
: return "objective-c";
342 case IK_ObjCXX
: return "objective-c++";
343 case IK_OpenCL
: return "cl";
344 case IK_CUDA
: return "cuda";
345 case IK_PreprocessedC
: return "cpp-output";
346 case IK_PreprocessedCXX
: return "c++-cpp-output";
347 case IK_PreprocessedObjC
: return "objective-c-cpp-output";
348 case IK_PreprocessedObjCXX
:return "objective-c++-cpp-output";
351 llvm_unreachable("Unexpected language kind!");
355 static const char *getActionName(frontend::ActionKind Kind
) {
357 case frontend::PluginAction
:
358 llvm_unreachable("Invalid kind!");
360 case frontend::ASTDump
: return "-ast-dump";
361 case frontend::ASTDumpXML
: return "-ast-dump-xml";
362 case frontend::ASTPrint
: return "-ast-print";
363 case frontend::ASTView
: return "-ast-view";
364 case frontend::CreateModule
: return "-create-module";
365 case frontend::DumpRawTokens
: return "-dump-raw-tokens";
366 case frontend::DumpTokens
: return "-dump-tokens";
367 case frontend::EmitAssembly
: return "-S";
368 case frontend::EmitBC
: return "-emit-llvm-bc";
369 case frontend::EmitHTML
: return "-emit-html";
370 case frontend::EmitLLVM
: return "-emit-llvm";
371 case frontend::EmitLLVMOnly
: return "-emit-llvm-only";
372 case frontend::EmitCodeGenOnly
: return "-emit-codegen-only";
373 case frontend::EmitObj
: return "-emit-obj";
374 case frontend::FixIt
: return "-fixit";
375 case frontend::GeneratePCH
: return "-emit-pch";
376 case frontend::GeneratePTH
: return "-emit-pth";
377 case frontend::InitOnly
: return "-init-only";
378 case frontend::ParseSyntaxOnly
: return "-fsyntax-only";
379 case frontend::PrintDeclContext
: return "-print-decl-contexts";
380 case frontend::PrintPreamble
: return "-print-preamble";
381 case frontend::PrintPreprocessedInput
: return "-E";
382 case frontend::RewriteMacros
: return "-rewrite-macros";
383 case frontend::RewriteObjC
: return "-rewrite-objc";
384 case frontend::RewriteTest
: return "-rewrite-test";
385 case frontend::RunAnalysis
: return "-analyze";
386 case frontend::RunPreprocessorOnly
: return "-Eonly";
389 llvm_unreachable("Unexpected language kind!");
393 static void FileSystemOptsToArgs(const FileSystemOptions
&Opts
,
394 std::vector
<std::string
> &Res
) {
395 if (!Opts
.WorkingDir
.empty()) {
396 Res
.push_back("-working-directory");
397 Res
.push_back(Opts
.WorkingDir
);
401 static void FrontendOptsToArgs(const FrontendOptions
&Opts
,
402 std::vector
<std::string
> &Res
) {
403 if (Opts
.DisableFree
)
404 Res
.push_back("-disable-free");
405 if (Opts
.RelocatablePCH
)
406 Res
.push_back("-relocatable-pch");
408 Res
.push_back("-chained-pch");
410 Res
.push_back("-help");
411 if (Opts
.ShowMacrosInCodeCompletion
)
412 Res
.push_back("-code-completion-macros");
413 if (Opts
.ShowCodePatternsInCodeCompletion
)
414 Res
.push_back("-code-completion-patterns");
415 if (!Opts
.ShowGlobalSymbolsInCodeCompletion
)
416 Res
.push_back("-no-code-completion-globals");
418 Res
.push_back("-print-stats");
420 Res
.push_back("-ftime-report");
421 if (Opts
.ShowVersion
)
422 Res
.push_back("-version");
423 if (Opts
.FixWhatYouCan
)
424 Res
.push_back("-fix-what-you-can");
425 switch (Opts
.ARCMTAction
) {
426 case FrontendOptions::ARCMT_None
:
428 case FrontendOptions::ARCMT_Check
:
429 Res
.push_back("-arcmt-check");
431 case FrontendOptions::ARCMT_Modify
:
432 Res
.push_back("-arcmt-modify");
434 case FrontendOptions::ARCMT_Migrate
:
435 Res
.push_back("-arcmt-migrate");
438 if (!Opts
.ARCMTMigrateDir
.empty()) {
439 Res
.push_back("-arcmt-migrate-directory");
440 Res
.push_back(Opts
.ARCMTMigrateDir
);
443 bool NeedLang
= false;
444 for (unsigned i
= 0, e
= Opts
.Inputs
.size(); i
!= e
; ++i
)
445 if (FrontendOptions::getInputKindForExtension(Opts
.Inputs
[i
].second
) !=
446 Opts
.Inputs
[i
].first
)
450 Res
.push_back(getInputKindName(Opts
.Inputs
[0].first
));
452 for (unsigned i
= 0, e
= Opts
.Inputs
.size(); i
!= e
; ++i
) {
453 assert((!NeedLang
|| Opts
.Inputs
[i
].first
== Opts
.Inputs
[0].first
) &&
454 "Unable to represent this input vector!");
455 Res
.push_back(Opts
.Inputs
[i
].second
);
458 if (!Opts
.OutputFile
.empty()) {
460 Res
.push_back(Opts
.OutputFile
);
462 if (!Opts
.CodeCompletionAt
.FileName
.empty()) {
463 Res
.push_back("-code-completion-at");
464 Res
.push_back(Opts
.CodeCompletionAt
.FileName
+ ":" +
465 llvm::utostr(Opts
.CodeCompletionAt
.Line
) + ":" +
466 llvm::utostr(Opts
.CodeCompletionAt
.Column
));
468 if (Opts
.ProgramAction
!= frontend::PluginAction
)
469 Res
.push_back(getActionName(Opts
.ProgramAction
));
470 if (!Opts
.ActionName
.empty()) {
471 Res
.push_back("-plugin");
472 Res
.push_back(Opts
.ActionName
);
473 for(unsigned i
= 0, e
= Opts
.PluginArgs
.size(); i
!= e
; ++i
) {
474 Res
.push_back("-plugin-arg-" + Opts
.ActionName
);
475 Res
.push_back(Opts
.PluginArgs
[i
]);
478 for (unsigned i
= 0, e
= Opts
.Plugins
.size(); i
!= e
; ++i
) {
479 Res
.push_back("-load");
480 Res
.push_back(Opts
.Plugins
[i
]);
482 for (unsigned i
= 0, e
= Opts
.AddPluginActions
.size(); i
!= e
; ++i
) {
483 Res
.push_back("-add-plugin");
484 Res
.push_back(Opts
.AddPluginActions
[i
]);
485 for(unsigned ai
= 0, ae
= Opts
.AddPluginArgs
.size(); ai
!= ae
; ++ai
) {
486 Res
.push_back("-plugin-arg-" + Opts
.AddPluginActions
[i
]);
487 Res
.push_back(Opts
.AddPluginArgs
[i
][ai
]);
490 for (unsigned i
= 0, e
= Opts
.ASTMergeFiles
.size(); i
!= e
; ++i
) {
491 Res
.push_back("-ast-merge");
492 Res
.push_back(Opts
.ASTMergeFiles
[i
]);
494 for (unsigned i
= 0, e
= Opts
.Modules
.size(); i
!= e
; ++i
) {
495 Res
.push_back("-import-module");
496 Res
.push_back(Opts
.Modules
[i
]);
498 for (unsigned i
= 0, e
= Opts
.LLVMArgs
.size(); i
!= e
; ++i
) {
499 Res
.push_back("-mllvm");
500 Res
.push_back(Opts
.LLVMArgs
[i
]);
504 static void HeaderSearchOptsToArgs(const HeaderSearchOptions
&Opts
,
505 std::vector
<std::string
> &Res
) {
506 if (Opts
.Sysroot
!= "/") {
507 Res
.push_back("-isysroot");
508 Res
.push_back(Opts
.Sysroot
);
511 /// User specified include entries.
512 for (unsigned i
= 0, e
= Opts
.UserEntries
.size(); i
!= e
; ++i
) {
513 const HeaderSearchOptions::Entry
&E
= Opts
.UserEntries
[i
];
514 if (E
.IsFramework
&& (E
.Group
!= frontend::Angled
|| !E
.IsUserSupplied
))
515 llvm::report_fatal_error("Invalid option set!");
516 if (E
.IsUserSupplied
) {
517 if (E
.Group
== frontend::After
) {
518 Res
.push_back("-idirafter");
519 } else if (E
.Group
== frontend::Quoted
) {
520 Res
.push_back("-iquote");
521 } else if (E
.Group
== frontend::System
) {
522 Res
.push_back("-isystem");
523 } else if (E
.Group
== frontend::CXXSystem
) {
524 Res
.push_back("-cxx-isystem");
526 assert(E
.Group
== frontend::Angled
&& "Invalid group!");
527 Res
.push_back(E
.IsFramework
? "-F" : "-I");
530 if (E
.Group
!= frontend::Angled
&& E
.Group
!= frontend::System
)
531 llvm::report_fatal_error("Invalid option set!");
532 Res
.push_back(E
.Group
== frontend::Angled
? "-iwithprefixbefore" :
535 Res
.push_back(E
.Path
);
538 if (!Opts
.EnvIncPath
.empty()) {
539 // FIXME: Provide an option for this, and move env detection to driver.
540 llvm::report_fatal_error("Not yet implemented!");
542 if (!Opts
.CEnvIncPath
.empty()) {
543 // FIXME: Provide an option for this, and move env detection to driver.
544 llvm::report_fatal_error("Not yet implemented!");
546 if (!Opts
.ObjCEnvIncPath
.empty()) {
547 // FIXME: Provide an option for this, and move env detection to driver.
548 llvm::report_fatal_error("Not yet implemented!");
550 if (!Opts
.CXXEnvIncPath
.empty()) {
551 // FIXME: Provide an option for this, and move env detection to driver.
552 llvm::report_fatal_error("Not yet implemented!");
554 if (!Opts
.ObjCXXEnvIncPath
.empty()) {
555 // FIXME: Provide an option for this, and move env detection to driver.
556 llvm::report_fatal_error("Not yet implemented!");
558 if (!Opts
.ResourceDir
.empty()) {
559 Res
.push_back("-resource-dir");
560 Res
.push_back(Opts
.ResourceDir
);
562 if (!Opts
.UseStandardIncludes
)
563 Res
.push_back("-nostdinc");
564 if (!Opts
.UseStandardCXXIncludes
)
565 Res
.push_back("-nostdinc++");
567 Res
.push_back("-stdlib=libc++");
572 static void LangOptsToArgs(const LangOptions
&Opts
,
573 std::vector
<std::string
> &Res
) {
574 LangOptions DefaultLangOpts
;
576 // FIXME: Need to set -std to get all the implicit options.
578 // FIXME: We want to only pass options relative to the defaults, which
579 // requires constructing a target. :(
581 // It would be better to push the all target specific choices into the driver,
582 // so that everything below that was more uniform.
585 Res
.push_back("-trigraphs");
586 // Implicit based on the input kind:
587 // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
588 // Implicit based on the input language standard:
589 // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
590 if (Opts
.DollarIdents
)
591 Res
.push_back("-fdollars-in-identifiers");
592 if (Opts
.GNUMode
&& !Opts
.GNUKeywords
)
593 Res
.push_back("-fno-gnu-keywords");
594 if (!Opts
.GNUMode
&& Opts
.GNUKeywords
)
595 Res
.push_back("-fgnu-keywords");
597 Res
.push_back("-fms-extensions");
598 if (Opts
.MSCVersion
!= 0)
599 Res
.push_back("-fmsc-version=" + llvm::utostr(Opts
.MSCVersion
));
601 Res
.push_back("-fborland-extensions");
602 if (Opts
.ObjCNonFragileABI
)
603 Res
.push_back("-fobjc-nonfragile-abi");
604 if (Opts
.ObjCNonFragileABI2
)
605 Res
.push_back("-fobjc-nonfragile-abi");
606 if (Opts
.ObjCDefaultSynthProperties
)
607 Res
.push_back("-fobjc-default-synthesize-properties");
608 // NoInline is implicit.
609 if (!Opts
.CXXOperatorNames
)
610 Res
.push_back("-fno-operator-names");
611 if (Opts
.PascalStrings
)
612 Res
.push_back("-fpascal-strings");
613 if (Opts
.CatchUndefined
)
614 Res
.push_back("-fcatch-undefined-behavior");
615 if (Opts
.WritableStrings
)
616 Res
.push_back("-fwritable-strings");
617 if (Opts
.ConstStrings
)
618 Res
.push_back("-fconst-strings");
619 if (!Opts
.LaxVectorConversions
)
620 Res
.push_back("-fno-lax-vector-conversions");
622 Res
.push_back("-faltivec");
624 Res
.push_back("-fexceptions");
625 if (Opts
.ObjCExceptions
)
626 Res
.push_back("-fobjc-exceptions");
627 if (Opts
.CXXExceptions
)
628 Res
.push_back("-fcxx-exceptions");
629 if (Opts
.SjLjExceptions
)
630 Res
.push_back("-fsjlj-exceptions");
631 if (Opts
.TraditionalCPP
)
632 Res
.push_back("-traditional-cpp");
634 Res
.push_back("-fno-rtti");
635 if (Opts
.MSBitfields
)
636 Res
.push_back("-mms-bitfields");
637 if (!Opts
.NeXTRuntime
)
638 Res
.push_back("-fgnu-runtime");
639 if (Opts
.Freestanding
)
640 Res
.push_back("-ffreestanding");
642 Res
.push_back("-fno-builtin");
643 if (!Opts
.AssumeSaneOperatorNew
)
644 Res
.push_back("-fno-assume-sane-operator-new");
645 if (!Opts
.ThreadsafeStatics
)
646 Res
.push_back("-fno-threadsafe-statics");
647 if (Opts
.POSIXThreads
)
648 Res
.push_back("-pthread");
650 Res
.push_back("-fblocks");
651 if (Opts
.EmitAllDecls
)
652 Res
.push_back("-femit-all-decls");
654 Res
.push_back("-fmath-errno");
655 switch (Opts
.getSignedOverflowBehavior()) {
656 case LangOptions::SOB_Undefined
: break;
657 case LangOptions::SOB_Defined
: Res
.push_back("-fwrapv"); break;
658 case LangOptions::SOB_Trapping
:
659 Res
.push_back("-ftrapv"); break;
660 if (!Opts
.OverflowHandler
.empty()) {
661 Res
.push_back("-ftrapv-handler");
662 Res
.push_back(Opts
.OverflowHandler
);
665 if (Opts
.HeinousExtensions
)
666 Res
.push_back("-fheinous-gnu-extensions");
667 // Optimize is implicit.
668 // OptimizeSize is implicit.
670 Res
.push_back("-static-define");
671 if (Opts
.DumpRecordLayouts
)
672 Res
.push_back("-fdump-record-layouts");
673 if (Opts
.DumpVTableLayouts
)
674 Res
.push_back("-fdump-vtable-layouts");
675 if (Opts
.NoBitFieldTypeAlign
)
676 Res
.push_back("-fno-bitfield-type-alignment");
678 Res
.push_back("-pic-level");
679 Res
.push_back(llvm::utostr(Opts
.PICLevel
));
681 if (Opts
.ObjCGCBitmapPrint
)
682 Res
.push_back("-print-ivar-layout");
683 if (Opts
.NoConstantCFStrings
)
684 Res
.push_back("-fno-constant-cfstrings");
685 if (!Opts
.AccessControl
)
686 Res
.push_back("-fno-access-control");
687 if (!Opts
.CharIsSigned
)
688 Res
.push_back("-fno-signed-char");
690 Res
.push_back("-fshort-wchar");
691 if (!Opts
.ElideConstructors
)
692 Res
.push_back("-fno-elide-constructors");
693 if (Opts
.getGCMode() != LangOptions::NonGC
) {
694 if (Opts
.getGCMode() == LangOptions::HybridGC
) {
695 Res
.push_back("-fobjc-gc");
697 assert(Opts
.getGCMode() == LangOptions::GCOnly
&& "Invalid GC mode!");
698 Res
.push_back("-fobjc-gc-only");
701 if (Opts
.ObjCAutoRefCount
)
702 Res
.push_back("-fobjc-arc");
703 if (Opts
.ObjCRuntimeHasWeak
)
704 Res
.push_back("-fobjc-runtime-has-weak");
705 if (!Opts
.ObjCInferRelatedResultType
)
706 Res
.push_back("-fno-objc-infer-related-result-type");
709 Res
.push_back("-fapple-kext");
711 if (Opts
.getVisibilityMode() != DefaultVisibility
) {
712 Res
.push_back("-fvisibility");
713 if (Opts
.getVisibilityMode() == HiddenVisibility
) {
714 Res
.push_back("hidden");
716 assert(Opts
.getVisibilityMode() == ProtectedVisibility
&&
717 "Invalid visibility!");
718 Res
.push_back("protected");
721 if (Opts
.InlineVisibilityHidden
)
722 Res
.push_back("-fvisibility-inlines-hidden");
724 if (Opts
.getStackProtectorMode() != 0) {
725 Res
.push_back("-stack-protector");
726 Res
.push_back(llvm::utostr(Opts
.getStackProtectorMode()));
728 if (Opts
.InstantiationDepth
!= DefaultLangOpts
.InstantiationDepth
) {
729 Res
.push_back("-ftemplate-depth");
730 Res
.push_back(llvm::utostr(Opts
.InstantiationDepth
));
732 if (!Opts
.ObjCConstantStringClass
.empty()) {
733 Res
.push_back("-fconstant-string-class");
734 Res
.push_back(Opts
.ObjCConstantStringClass
);
736 if (Opts
.FakeAddressSpaceMap
)
737 Res
.push_back("-ffake-address-space-map");
738 if (Opts
.ParseUnknownAnytype
)
739 Res
.push_back("-funknown-anytype");
740 if (Opts
.DelayedTemplateParsing
)
741 Res
.push_back("-fdelayed-template-parsing");
743 Res
.push_back("-fdeprecated-macro");
746 static void PreprocessorOptsToArgs(const PreprocessorOptions
&Opts
,
747 std::vector
<std::string
> &Res
) {
748 for (unsigned i
= 0, e
= Opts
.Macros
.size(); i
!= e
; ++i
)
749 Res
.push_back(std::string(Opts
.Macros
[i
].second
? "-U" : "-D") +
750 Opts
.Macros
[i
].first
);
751 for (unsigned i
= 0, e
= Opts
.Includes
.size(); i
!= e
; ++i
) {
752 // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
753 Res
.push_back("-include");
754 Res
.push_back(Opts
.Includes
[i
]);
756 for (unsigned i
= 0, e
= Opts
.MacroIncludes
.size(); i
!= e
; ++i
) {
757 Res
.push_back("-imacros");
758 Res
.push_back(Opts
.MacroIncludes
[i
]);
760 if (!Opts
.UsePredefines
)
761 Res
.push_back("-undef");
762 if (Opts
.DetailedRecord
)
763 Res
.push_back("-detailed-preprocessing-record");
764 if (!Opts
.ImplicitPCHInclude
.empty()) {
765 Res
.push_back("-include-pch");
766 Res
.push_back(Opts
.ImplicitPCHInclude
);
768 if (!Opts
.ImplicitPTHInclude
.empty()) {
769 Res
.push_back("-include-pth");
770 Res
.push_back(Opts
.ImplicitPTHInclude
);
772 if (!Opts
.TokenCache
.empty()) {
773 if (Opts
.ImplicitPTHInclude
.empty()) {
774 Res
.push_back("-token-cache");
775 Res
.push_back(Opts
.TokenCache
);
777 assert(Opts
.ImplicitPTHInclude
== Opts
.TokenCache
&&
778 "Unsupported option combination!");
780 for (unsigned i
= 0, e
= Opts
.ChainedIncludes
.size(); i
!= e
; ++i
) {
781 Res
.push_back("-chain-include");
782 Res
.push_back(Opts
.ChainedIncludes
[i
]);
784 for (unsigned i
= 0, e
= Opts
.RemappedFiles
.size(); i
!= e
; ++i
) {
785 Res
.push_back("-remap-file");
786 Res
.push_back(Opts
.RemappedFiles
[i
].first
+ ";" +
787 Opts
.RemappedFiles
[i
].second
);
791 static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions
&Opts
,
792 std::vector
<std::string
> &Res
) {
793 if (!Opts
.ShowCPP
&& !Opts
.ShowMacros
)
794 llvm::report_fatal_error("Invalid option combination!");
796 if (Opts
.ShowCPP
&& Opts
.ShowMacros
)
797 Res
.push_back("-dD");
798 else if (!Opts
.ShowCPP
&& Opts
.ShowMacros
)
799 Res
.push_back("-dM");
801 if (!Opts
.ShowLineMarkers
)
803 if (Opts
.ShowComments
)
805 if (Opts
.ShowMacroComments
)
806 Res
.push_back("-CC");
809 static void TargetOptsToArgs(const TargetOptions
&Opts
,
810 std::vector
<std::string
> &Res
) {
811 Res
.push_back("-triple");
812 Res
.push_back(Opts
.Triple
);
813 if (!Opts
.CPU
.empty()) {
814 Res
.push_back("-target-cpu");
815 Res
.push_back(Opts
.CPU
);
817 if (!Opts
.ABI
.empty()) {
818 Res
.push_back("-target-abi");
819 Res
.push_back(Opts
.ABI
);
821 if (!Opts
.LinkerVersion
.empty()) {
822 Res
.push_back("-target-linker-version");
823 Res
.push_back(Opts
.LinkerVersion
);
825 if (!Opts
.CXXABI
.empty()) {
826 Res
.push_back("-cxx-abi");
827 Res
.push_back(Opts
.CXXABI
);
829 for (unsigned i
= 0, e
= Opts
.Features
.size(); i
!= e
; ++i
) {
830 Res
.push_back("-target-feature");
831 Res
.push_back(Opts
.Features
[i
]);
835 void CompilerInvocation::toArgs(std::vector
<std::string
> &Res
) {
836 AnalyzerOptsToArgs(getAnalyzerOpts(), Res
);
837 CodeGenOptsToArgs(getCodeGenOpts(), Res
);
838 DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res
);
839 DiagnosticOptsToArgs(getDiagnosticOpts(), Res
);
840 FileSystemOptsToArgs(getFileSystemOpts(), Res
);
841 FrontendOptsToArgs(getFrontendOpts(), Res
);
842 HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res
);
843 LangOptsToArgs(getLangOpts(), Res
);
844 PreprocessorOptsToArgs(getPreprocessorOpts(), Res
);
845 PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res
);
846 TargetOptsToArgs(getTargetOpts(), Res
);
849 //===----------------------------------------------------------------------===//
850 // Deserialization (to args)
851 //===----------------------------------------------------------------------===//
853 using namespace clang::driver
;
854 using namespace clang::driver::cc1options
;
858 static unsigned getOptimizationLevel(ArgList
&Args
, InputKind IK
,
860 unsigned DefaultOpt
= 0;
861 if (IK
== IK_OpenCL
&& !Args
.hasArg(OPT_cl_opt_disable
))
863 // -Os/-Oz implies -O2
864 return (Args
.hasArg(OPT_Os
) || Args
.hasArg (OPT_Oz
)) ? 2 :
865 Args
.getLastArgIntValue(OPT_O
, DefaultOpt
, Diags
);
868 static void ParseAnalyzerArgs(AnalyzerOptions
&Opts
, ArgList
&Args
,
870 using namespace cc1options
;
872 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_store
)) {
873 llvm::StringRef Name
= A
->getValue(Args
);
874 AnalysisStores Value
= llvm::StringSwitch
<AnalysisStores
>(Name
)
875 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
876 .Case(CMDFLAG, NAME##Model)
877 #include "clang/Frontend/Analyses.def"
879 // FIXME: Error handling.
880 if (Value
== NumStores
)
881 Diags
.Report(diag::err_drv_invalid_value
)
882 << A
->getAsString(Args
) << Name
;
884 Opts
.AnalysisStoreOpt
= Value
;
887 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_constraints
)) {
888 llvm::StringRef Name
= A
->getValue(Args
);
889 AnalysisConstraints Value
= llvm::StringSwitch
<AnalysisConstraints
>(Name
)
890 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
891 .Case(CMDFLAG, NAME##Model)
892 #include "clang/Frontend/Analyses.def"
893 .Default(NumConstraints
);
894 // FIXME: Error handling.
895 if (Value
== NumConstraints
)
896 Diags
.Report(diag::err_drv_invalid_value
)
897 << A
->getAsString(Args
) << Name
;
899 Opts
.AnalysisConstraintsOpt
= Value
;
902 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_output
)) {
903 llvm::StringRef Name
= A
->getValue(Args
);
904 AnalysisDiagClients Value
= llvm::StringSwitch
<AnalysisDiagClients
>(Name
)
905 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
906 .Case(CMDFLAG, PD_##NAME)
907 #include "clang/Frontend/Analyses.def"
908 .Default(NUM_ANALYSIS_DIAG_CLIENTS
);
909 // FIXME: Error handling.
910 if (Value
== NUM_ANALYSIS_DIAG_CLIENTS
)
911 Diags
.Report(diag::err_drv_invalid_value
)
912 << A
->getAsString(Args
) << Name
;
914 Opts
.AnalysisDiagOpt
= Value
;
917 Opts
.ShowCheckerHelp
= Args
.hasArg(OPT_analyzer_checker_help
);
918 Opts
.VisualizeEGDot
= Args
.hasArg(OPT_analyzer_viz_egraph_graphviz
);
919 Opts
.VisualizeEGUbi
= Args
.hasArg(OPT_analyzer_viz_egraph_ubigraph
);
920 Opts
.AnalyzeAll
= Args
.hasArg(OPT_analyzer_opt_analyze_headers
);
921 Opts
.AnalyzerDisplayProgress
= Args
.hasArg(OPT_analyzer_display_progress
);
922 Opts
.AnalyzeNestedBlocks
=
923 Args
.hasArg(OPT_analyzer_opt_analyze_nested_blocks
);
924 Opts
.PurgeDead
= !Args
.hasArg(OPT_analyzer_no_purge_dead
);
925 Opts
.EagerlyAssume
= Args
.hasArg(OPT_analyzer_eagerly_assume
);
926 Opts
.AnalyzeSpecificFunction
= Args
.getLastArgValue(OPT_analyze_function
);
927 Opts
.UnoptimizedCFG
= Args
.hasArg(OPT_analysis_UnoptimizedCFG
);
928 Opts
.CFGAddImplicitDtors
= Args
.hasArg(OPT_analysis_CFGAddImplicitDtors
);
929 Opts
.CFGAddInitializers
= Args
.hasArg(OPT_analysis_CFGAddInitializers
);
930 Opts
.TrimGraph
= Args
.hasArg(OPT_trim_egraph
);
931 Opts
.MaxNodes
= Args
.getLastArgIntValue(OPT_analyzer_max_nodes
, 150000,Diags
);
932 Opts
.MaxLoop
= Args
.getLastArgIntValue(OPT_analyzer_max_loop
, 4, Diags
);
933 Opts
.EagerlyTrimEGraph
= !Args
.hasArg(OPT_analyzer_no_eagerly_trim_egraph
);
934 Opts
.InlineCall
= Args
.hasArg(OPT_analyzer_inline_call
);
936 Opts
.CheckersControlList
.clear();
937 for (arg_iterator it
= Args
.filtered_begin(OPT_analyzer_checker
,
938 OPT_analyzer_disable_checker
),
939 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
942 bool enable
= (A
->getOption().getID() == OPT_analyzer_checker
);
943 // We can have a list of comma separated checker names, e.g:
944 // '-analyzer-checker=cocoa,unix'
945 llvm::StringRef checkerList
= A
->getValue(Args
);
946 llvm::SmallVector
<llvm::StringRef
, 4> checkers
;
947 checkerList
.split(checkers
, ",");
948 for (unsigned i
= 0, e
= checkers
.size(); i
!= e
; ++i
)
949 Opts
.CheckersControlList
.push_back(std::make_pair(checkers
[i
], enable
));
953 static void ParseCodeGenArgs(CodeGenOptions
&Opts
, ArgList
&Args
, InputKind IK
,
955 using namespace cc1options
;
957 Opts
.OptimizationLevel
= getOptimizationLevel(Args
, IK
, Diags
);
958 if (Opts
.OptimizationLevel
> 3) {
959 Diags
.Report(diag::err_drv_invalid_value
)
960 << Args
.getLastArg(OPT_O
)->getAsString(Args
) << Opts
.OptimizationLevel
;
961 Opts
.OptimizationLevel
= 3;
964 // We must always run at least the always inlining pass.
965 Opts
.Inlining
= (Opts
.OptimizationLevel
> 1) ? CodeGenOptions::NormalInlining
966 : CodeGenOptions::OnlyAlwaysInlining
;
968 Opts
.DebugInfo
= Args
.hasArg(OPT_g
);
969 Opts
.LimitDebugInfo
= Args
.hasArg(OPT_flimit_debug_info
);
970 Opts
.DisableLLVMOpts
= Args
.hasArg(OPT_disable_llvm_optzns
);
971 Opts
.DisableRedZone
= Args
.hasArg(OPT_disable_red_zone
);
972 Opts
.ForbidGuardVariables
= Args
.hasArg(OPT_fforbid_guard_variables
);
973 Opts
.UseRegisterSizedBitfieldAccess
= Args
.hasArg(
974 OPT_fuse_register_sized_bitfield_access
);
975 Opts
.RelaxedAliasing
= Args
.hasArg(OPT_relaxed_aliasing
);
976 Opts
.DwarfDebugFlags
= Args
.getLastArgValue(OPT_dwarf_debug_flags
);
977 Opts
.MergeAllConstants
= !Args
.hasArg(OPT_fno_merge_all_constants
);
978 Opts
.NoCommon
= Args
.hasArg(OPT_fno_common
);
979 Opts
.NoImplicitFloat
= Args
.hasArg(OPT_no_implicit_float
);
980 Opts
.OptimizeSize
= Args
.hasArg(OPT_Os
);
981 Opts
.OptimizeSize
= Args
.hasArg(OPT_Oz
) ? 2 : Opts
.OptimizeSize
;
982 Opts
.SimplifyLibCalls
= !(Args
.hasArg(OPT_fno_builtin
) ||
983 Args
.hasArg(OPT_ffreestanding
));
984 Opts
.UnrollLoops
= Args
.hasArg(OPT_funroll_loops
) ||
985 (Opts
.OptimizationLevel
> 1 && !Opts
.OptimizeSize
);
987 Opts
.AsmVerbose
= Args
.hasArg(OPT_masm_verbose
);
988 Opts
.ObjCAutoRefCountExceptions
= Args
.hasArg(OPT_fobjc_arc_exceptions
);
989 Opts
.ObjCRuntimeHasARC
= Args
.hasArg(OPT_fobjc_runtime_has_arc
);
990 Opts
.ObjCRuntimeHasTerminate
= Args
.hasArg(OPT_fobjc_runtime_has_terminate
);
991 Opts
.CXAAtExit
= !Args
.hasArg(OPT_fno_use_cxa_atexit
);
992 Opts
.CXXCtorDtorAliases
= Args
.hasArg(OPT_mconstructor_aliases
);
993 Opts
.CodeModel
= Args
.getLastArgValue(OPT_mcode_model
);
994 Opts
.DebugPass
= Args
.getLastArgValue(OPT_mdebug_pass
);
995 Opts
.DisableFPElim
= Args
.hasArg(OPT_mdisable_fp_elim
);
996 Opts
.FloatABI
= Args
.getLastArgValue(OPT_mfloat_abi
);
997 Opts
.HiddenWeakVTables
= Args
.hasArg(OPT_fhidden_weak_vtables
);
998 Opts
.LessPreciseFPMAD
= Args
.hasArg(OPT_cl_mad_enable
);
999 Opts
.LimitFloatPrecision
= Args
.getLastArgValue(OPT_mlimit_float_precision
);
1000 Opts
.NoInfsFPMath
= Opts
.NoNaNsFPMath
= Args
.hasArg(OPT_cl_finite_math_only
)||
1001 Args
.hasArg(OPT_cl_fast_relaxed_math
);
1002 Opts
.NoZeroInitializedInBSS
= Args
.hasArg(OPT_mno_zero_initialized_in_bss
);
1003 Opts
.BackendOptions
= Args
.getAllArgValues(OPT_backend_option
);
1004 Opts
.NumRegisterParameters
= Args
.getLastArgIntValue(OPT_mregparm
, 0, Diags
);
1005 Opts
.NoExecStack
= Args
.hasArg(OPT_mno_exec_stack
);
1006 Opts
.RelaxAll
= Args
.hasArg(OPT_mrelax_all
);
1007 Opts
.OmitLeafFramePointer
= Args
.hasArg(OPT_momit_leaf_frame_pointer
);
1008 Opts
.SaveTempLabels
= Args
.hasArg(OPT_msave_temp_labels
);
1009 Opts
.NoDwarf2CFIAsm
= Args
.hasArg(OPT_fno_dwarf2_cfi_asm
);
1010 Opts
.SoftFloat
= Args
.hasArg(OPT_msoft_float
);
1011 Opts
.UnsafeFPMath
= Args
.hasArg(OPT_cl_unsafe_math_optimizations
) ||
1012 Args
.hasArg(OPT_cl_fast_relaxed_math
);
1013 Opts
.UnwindTables
= Args
.hasArg(OPT_munwind_tables
);
1014 Opts
.RelocationModel
= Args
.getLastArgValue(OPT_mrelocation_model
, "pic");
1016 Opts
.FunctionSections
= Args
.hasArg(OPT_ffunction_sections
);
1017 Opts
.DataSections
= Args
.hasArg(OPT_fdata_sections
);
1019 Opts
.MainFileName
= Args
.getLastArgValue(OPT_main_file_name
);
1020 Opts
.VerifyModule
= !Args
.hasArg(OPT_disable_llvm_verifier
);
1022 Opts
.InstrumentFunctions
= Args
.hasArg(OPT_finstrument_functions
);
1023 Opts
.InstrumentForProfiling
= Args
.hasArg(OPT_pg
);
1024 Opts
.EmitGcovArcs
= Args
.hasArg(OPT_femit_coverage_data
);
1025 Opts
.EmitGcovNotes
= Args
.hasArg(OPT_femit_coverage_notes
);
1026 Opts
.CoverageFile
= Args
.getLastArgValue(OPT_coverage_file
);
1028 if (Arg
*A
= Args
.getLastArg(OPT_fobjc_dispatch_method_EQ
)) {
1029 llvm::StringRef Name
= A
->getValue(Args
);
1030 unsigned Method
= llvm::StringSwitch
<unsigned>(Name
)
1031 .Case("legacy", CodeGenOptions::Legacy
)
1032 .Case("non-legacy", CodeGenOptions::NonLegacy
)
1033 .Case("mixed", CodeGenOptions::Mixed
)
1036 Diags
.Report(diag::err_drv_invalid_value
) << A
->getAsString(Args
) << Name
;
1038 Opts
.ObjCDispatchMethod
= Method
;
1042 static void ParseDependencyOutputArgs(DependencyOutputOptions
&Opts
,
1044 using namespace cc1options
;
1045 Opts
.OutputFile
= Args
.getLastArgValue(OPT_dependency_file
);
1046 Opts
.Targets
= Args
.getAllArgValues(OPT_MT
);
1047 Opts
.IncludeSystemHeaders
= Args
.hasArg(OPT_sys_header_deps
);
1048 Opts
.UsePhonyTargets
= Args
.hasArg(OPT_MP
);
1049 Opts
.ShowHeaderIncludes
= Args
.hasArg(OPT_H
);
1050 Opts
.HeaderIncludeOutputFile
= Args
.getLastArgValue(OPT_header_include_file
);
1053 static void ParseDiagnosticArgs(DiagnosticOptions
&Opts
, ArgList
&Args
,
1054 Diagnostic
&Diags
) {
1055 using namespace cc1options
;
1056 Opts
.DiagnosticLogFile
= Args
.getLastArgValue(OPT_diagnostic_log_file
);
1057 Opts
.IgnoreWarnings
= Args
.hasArg(OPT_w
);
1058 Opts
.NoRewriteMacros
= Args
.hasArg(OPT_Wno_rewrite_macros
);
1059 Opts
.Pedantic
= Args
.hasArg(OPT_pedantic
);
1060 Opts
.PedanticErrors
= Args
.hasArg(OPT_pedantic_errors
);
1061 Opts
.ShowCarets
= !Args
.hasArg(OPT_fno_caret_diagnostics
);
1062 Opts
.ShowColors
= Args
.hasArg(OPT_fcolor_diagnostics
);
1063 Opts
.ShowColumn
= Args
.hasFlag(OPT_fshow_column
,
1064 OPT_fno_show_column
,
1066 Opts
.ShowFixits
= !Args
.hasArg(OPT_fno_diagnostics_fixit_info
);
1067 Opts
.ShowLocation
= !Args
.hasArg(OPT_fno_show_source_location
);
1068 Opts
.ShowNames
= Args
.hasArg(OPT_fdiagnostics_show_name
);
1069 Opts
.ShowOptionNames
= Args
.hasArg(OPT_fdiagnostics_show_option
);
1071 // Default behavior is to not to show note include stacks.
1072 Opts
.ShowNoteIncludeStack
= false;
1073 if (Arg
*A
= Args
.getLastArg(OPT_fdiagnostics_show_note_include_stack
,
1074 OPT_fno_diagnostics_show_note_include_stack
))
1075 if (A
->getOption().matches(OPT_fdiagnostics_show_note_include_stack
))
1076 Opts
.ShowNoteIncludeStack
= true;
1078 llvm::StringRef ShowOverloads
=
1079 Args
.getLastArgValue(OPT_fshow_overloads_EQ
, "all");
1080 if (ShowOverloads
== "best")
1081 Opts
.ShowOverloads
= Diagnostic::Ovl_Best
;
1082 else if (ShowOverloads
== "all")
1083 Opts
.ShowOverloads
= Diagnostic::Ovl_All
;
1085 Diags
.Report(diag::err_drv_invalid_value
)
1086 << Args
.getLastArg(OPT_fshow_overloads_EQ
)->getAsString(Args
)
1089 llvm::StringRef ShowCategory
=
1090 Args
.getLastArgValue(OPT_fdiagnostics_show_category
, "none");
1091 if (ShowCategory
== "none")
1092 Opts
.ShowCategories
= 0;
1093 else if (ShowCategory
== "id")
1094 Opts
.ShowCategories
= 1;
1095 else if (ShowCategory
== "name")
1096 Opts
.ShowCategories
= 2;
1098 Diags
.Report(diag::err_drv_invalid_value
)
1099 << Args
.getLastArg(OPT_fdiagnostics_show_category
)->getAsString(Args
)
1102 llvm::StringRef Format
=
1103 Args
.getLastArgValue(OPT_fdiagnostics_format
, "clang");
1104 if (Format
== "clang")
1105 Opts
.Format
= DiagnosticOptions::Clang
;
1106 else if (Format
== "msvc")
1107 Opts
.Format
= DiagnosticOptions::Msvc
;
1108 else if (Format
== "vi")
1109 Opts
.Format
= DiagnosticOptions::Vi
;
1111 Diags
.Report(diag::err_drv_invalid_value
)
1112 << Args
.getLastArg(OPT_fdiagnostics_format
)->getAsString(Args
)
1115 Opts
.ShowSourceRanges
= Args
.hasArg(OPT_fdiagnostics_print_source_range_info
);
1116 Opts
.ShowParseableFixits
= Args
.hasArg(OPT_fdiagnostics_parseable_fixits
);
1117 Opts
.VerifyDiagnostics
= Args
.hasArg(OPT_verify
);
1118 Opts
.ErrorLimit
= Args
.getLastArgIntValue(OPT_ferror_limit
, 0, Diags
);
1119 Opts
.MacroBacktraceLimit
1120 = Args
.getLastArgIntValue(OPT_fmacro_backtrace_limit
,
1121 DiagnosticOptions::DefaultMacroBacktraceLimit
, Diags
);
1122 Opts
.TemplateBacktraceLimit
1123 = Args
.getLastArgIntValue(OPT_ftemplate_backtrace_limit
,
1124 DiagnosticOptions::DefaultTemplateBacktraceLimit
,
1126 Opts
.TabStop
= Args
.getLastArgIntValue(OPT_ftabstop
,
1127 DiagnosticOptions::DefaultTabStop
, Diags
);
1128 if (Opts
.TabStop
== 0 || Opts
.TabStop
> DiagnosticOptions::MaxTabStop
) {
1129 Diags
.Report(diag::warn_ignoring_ftabstop_value
)
1130 << Opts
.TabStop
<< DiagnosticOptions::DefaultTabStop
;
1131 Opts
.TabStop
= DiagnosticOptions::DefaultTabStop
;
1133 Opts
.MessageLength
= Args
.getLastArgIntValue(OPT_fmessage_length
, 0, Diags
);
1134 Opts
.DumpBuildInformation
= Args
.getLastArgValue(OPT_dump_build_information
);
1135 Opts
.Warnings
= Args
.getAllArgValues(OPT_W
);
1138 static void ParseFileSystemArgs(FileSystemOptions
&Opts
, ArgList
&Args
) {
1139 Opts
.WorkingDir
= Args
.getLastArgValue(OPT_working_directory
);
1142 static InputKind
ParseFrontendArgs(FrontendOptions
&Opts
, ArgList
&Args
,
1143 Diagnostic
&Diags
) {
1144 using namespace cc1options
;
1145 Opts
.ProgramAction
= frontend::ParseSyntaxOnly
;
1146 if (const Arg
*A
= Args
.getLastArg(OPT_Action_Group
)) {
1147 switch (A
->getOption().getID()) {
1149 assert(0 && "Invalid option in group!");
1151 Opts
.ProgramAction
= frontend::ASTDump
; break;
1152 case OPT_ast_dump_xml
:
1153 Opts
.ProgramAction
= frontend::ASTDumpXML
; break;
1155 Opts
.ProgramAction
= frontend::ASTPrint
; break;
1157 Opts
.ProgramAction
= frontend::ASTView
; break;
1158 case OPT_dump_raw_tokens
:
1159 Opts
.ProgramAction
= frontend::DumpRawTokens
; break;
1160 case OPT_dump_tokens
:
1161 Opts
.ProgramAction
= frontend::DumpTokens
; break;
1163 Opts
.ProgramAction
= frontend::EmitAssembly
; break;
1164 case OPT_emit_llvm_bc
:
1165 Opts
.ProgramAction
= frontend::EmitBC
; break;
1167 Opts
.ProgramAction
= frontend::EmitHTML
; break;
1169 Opts
.ProgramAction
= frontend::EmitLLVM
; break;
1170 case OPT_emit_llvm_only
:
1171 Opts
.ProgramAction
= frontend::EmitLLVMOnly
; break;
1172 case OPT_emit_codegen_only
:
1173 Opts
.ProgramAction
= frontend::EmitCodeGenOnly
; break;
1175 Opts
.ProgramAction
= frontend::EmitObj
; break;
1177 Opts
.FixItSuffix
= A
->getValue(Args
);
1180 Opts
.ProgramAction
= frontend::FixIt
; break;
1182 Opts
.ProgramAction
= frontend::GeneratePCH
; break;
1184 Opts
.ProgramAction
= frontend::GeneratePTH
; break;
1186 Opts
.ProgramAction
= frontend::InitOnly
; break;
1187 case OPT_fsyntax_only
:
1188 Opts
.ProgramAction
= frontend::ParseSyntaxOnly
; break;
1189 case OPT_print_decl_contexts
:
1190 Opts
.ProgramAction
= frontend::PrintDeclContext
; break;
1191 case OPT_print_preamble
:
1192 Opts
.ProgramAction
= frontend::PrintPreamble
; break;
1194 Opts
.ProgramAction
= frontend::PrintPreprocessedInput
; break;
1195 case OPT_rewrite_macros
:
1196 Opts
.ProgramAction
= frontend::RewriteMacros
; break;
1197 case OPT_rewrite_objc
:
1198 Opts
.ProgramAction
= frontend::RewriteObjC
; break;
1199 case OPT_rewrite_test
:
1200 Opts
.ProgramAction
= frontend::RewriteTest
; break;
1202 Opts
.ProgramAction
= frontend::RunAnalysis
; break;
1204 Opts
.ProgramAction
= frontend::RunPreprocessorOnly
; break;
1205 case OPT_create_module
:
1206 Opts
.ProgramAction
= frontend::CreateModule
; break;
1210 if (const Arg
* A
= Args
.getLastArg(OPT_plugin
)) {
1211 Opts
.Plugins
.push_back(A
->getValue(Args
,0));
1212 Opts
.ProgramAction
= frontend::PluginAction
;
1213 Opts
.ActionName
= A
->getValue(Args
);
1215 for (arg_iterator it
= Args
.filtered_begin(OPT_plugin_arg
),
1216 end
= Args
.filtered_end(); it
!= end
; ++it
) {
1217 if ((*it
)->getValue(Args
, 0) == Opts
.ActionName
)
1218 Opts
.PluginArgs
.push_back((*it
)->getValue(Args
, 1));
1222 Opts
.AddPluginActions
= Args
.getAllArgValues(OPT_add_plugin
);
1223 Opts
.AddPluginArgs
.resize(Opts
.AddPluginActions
.size());
1224 for (int i
= 0, e
= Opts
.AddPluginActions
.size(); i
!= e
; ++i
) {
1225 for (arg_iterator it
= Args
.filtered_begin(OPT_plugin_arg
),
1226 end
= Args
.filtered_end(); it
!= end
; ++it
) {
1227 if ((*it
)->getValue(Args
, 0) == Opts
.AddPluginActions
[i
])
1228 Opts
.AddPluginArgs
[i
].push_back((*it
)->getValue(Args
, 1));
1232 if (const Arg
*A
= Args
.getLastArg(OPT_code_completion_at
)) {
1233 Opts
.CodeCompletionAt
=
1234 ParsedSourceLocation::FromString(A
->getValue(Args
));
1235 if (Opts
.CodeCompletionAt
.FileName
.empty())
1236 Diags
.Report(diag::err_drv_invalid_value
)
1237 << A
->getAsString(Args
) << A
->getValue(Args
);
1239 Opts
.DisableFree
= Args
.hasArg(OPT_disable_free
);
1241 Opts
.OutputFile
= Args
.getLastArgValue(OPT_o
);
1242 Opts
.Plugins
= Args
.getAllArgValues(OPT_load
);
1243 Opts
.RelocatablePCH
= Args
.hasArg(OPT_relocatable_pch
);
1244 Opts
.ChainedPCH
= Args
.hasArg(OPT_chained_pch
);
1245 Opts
.ShowHelp
= Args
.hasArg(OPT_help
);
1246 Opts
.ShowMacrosInCodeCompletion
= Args
.hasArg(OPT_code_completion_macros
);
1247 Opts
.ShowCodePatternsInCodeCompletion
1248 = Args
.hasArg(OPT_code_completion_patterns
);
1249 Opts
.ShowGlobalSymbolsInCodeCompletion
1250 = !Args
.hasArg(OPT_no_code_completion_globals
);
1251 Opts
.ShowStats
= Args
.hasArg(OPT_print_stats
);
1252 Opts
.ShowTimers
= Args
.hasArg(OPT_ftime_report
);
1253 Opts
.ShowVersion
= Args
.hasArg(OPT_version
);
1254 Opts
.ASTMergeFiles
= Args
.getAllArgValues(OPT_ast_merge
);
1255 Opts
.LLVMArgs
= Args
.getAllArgValues(OPT_mllvm
);
1256 Opts
.FixWhatYouCan
= Args
.hasArg(OPT_fix_what_you_can
);
1257 Opts
.Modules
= Args
.getAllArgValues(OPT_import_module
);
1259 Opts
.ARCMTAction
= FrontendOptions::ARCMT_None
;
1260 if (const Arg
*A
= Args
.getLastArg(OPT_arcmt_check
,
1262 OPT_arcmt_migrate
)) {
1263 switch (A
->getOption().getID()) {
1265 llvm_unreachable("missed a case");
1266 case OPT_arcmt_check
:
1267 Opts
.ARCMTAction
= FrontendOptions::ARCMT_Check
;
1269 case OPT_arcmt_modify
:
1270 Opts
.ARCMTAction
= FrontendOptions::ARCMT_Modify
;
1272 case OPT_arcmt_migrate
:
1273 Opts
.ARCMTAction
= FrontendOptions::ARCMT_Migrate
;
1277 Opts
.ARCMTMigrateDir
= Args
.getLastArgValue(OPT_arcmt_migrate_directory
);
1279 InputKind DashX
= IK_None
;
1280 if (const Arg
*A
= Args
.getLastArg(OPT_x
)) {
1281 DashX
= llvm::StringSwitch
<InputKind
>(A
->getValue(Args
))
1283 .Case("cl", IK_OpenCL
)
1284 .Case("cuda", IK_CUDA
)
1285 .Case("c++", IK_CXX
)
1286 .Case("objective-c", IK_ObjC
)
1287 .Case("objective-c++", IK_ObjCXX
)
1288 .Case("cpp-output", IK_PreprocessedC
)
1289 .Case("assembler-with-cpp", IK_Asm
)
1290 .Case("c++-cpp-output", IK_PreprocessedCXX
)
1291 .Case("objective-c-cpp-output", IK_PreprocessedObjC
)
1292 .Case("objc-cpp-output", IK_PreprocessedObjC
)
1293 .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX
)
1294 .Case("c-header", IK_C
)
1295 .Case("objective-c-header", IK_ObjC
)
1296 .Case("c++-header", IK_CXX
)
1297 .Case("objective-c++-header", IK_ObjCXX
)
1298 .Case("ast", IK_AST
)
1299 .Case("ir", IK_LLVM_IR
)
1301 if (DashX
== IK_None
)
1302 Diags
.Report(diag::err_drv_invalid_value
)
1303 << A
->getAsString(Args
) << A
->getValue(Args
);
1306 // '-' is the default input if none is given.
1307 std::vector
<std::string
> Inputs
= Args
.getAllArgValues(OPT_INPUT
);
1308 Opts
.Inputs
.clear();
1310 Inputs
.push_back("-");
1311 for (unsigned i
= 0, e
= Inputs
.size(); i
!= e
; ++i
) {
1312 InputKind IK
= DashX
;
1313 if (IK
== IK_None
) {
1314 IK
= FrontendOptions::getInputKindForExtension(
1315 llvm::StringRef(Inputs
[i
]).rsplit('.').second
);
1316 // FIXME: Remove this hack.
1320 Opts
.Inputs
.push_back(std::make_pair(IK
, Inputs
[i
]));
1326 std::string
CompilerInvocation::GetResourcesPath(const char *Argv0
,
1328 llvm::sys::Path P
= llvm::sys::Path::GetMainExecutable(Argv0
, MainAddr
);
1331 P
.eraseComponent(); // Remove /clang from foo/bin/clang
1332 P
.eraseComponent(); // Remove /bin from foo/bin
1334 // Get foo/lib/clang/<version>/include
1335 P
.appendComponent("lib");
1336 P
.appendComponent("clang");
1337 P
.appendComponent(CLANG_VERSION_STRING
);
1343 static void ParseHeaderSearchArgs(HeaderSearchOptions
&Opts
, ArgList
&Args
) {
1344 using namespace cc1options
;
1345 Opts
.Sysroot
= Args
.getLastArgValue(OPT_isysroot
, "/");
1346 Opts
.Verbose
= Args
.hasArg(OPT_v
);
1347 Opts
.UseBuiltinIncludes
= !Args
.hasArg(OPT_nobuiltininc
);
1348 Opts
.UseStandardIncludes
= !Args
.hasArg(OPT_nostdinc
);
1349 Opts
.UseStandardCXXIncludes
= !Args
.hasArg(OPT_nostdincxx
);
1350 if (const Arg
*A
= Args
.getLastArg(OPT_stdlib_EQ
))
1351 Opts
.UseLibcxx
= (strcmp(A
->getValue(Args
), "libc++") == 0);
1352 Opts
.ResourceDir
= Args
.getLastArgValue(OPT_resource_dir
);
1354 // Add -I... and -F... options in order.
1355 for (arg_iterator it
= Args
.filtered_begin(OPT_I
, OPT_F
),
1356 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1357 Opts
.AddPath((*it
)->getValue(Args
), frontend::Angled
, true,
1358 /*IsFramework=*/ (*it
)->getOption().matches(OPT_F
), false);
1360 // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1361 llvm::StringRef Prefix
= ""; // FIXME: This isn't the correct default prefix.
1362 for (arg_iterator it
= Args
.filtered_begin(OPT_iprefix
, OPT_iwithprefix
,
1363 OPT_iwithprefixbefore
),
1364 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1366 if (A
->getOption().matches(OPT_iprefix
))
1367 Prefix
= A
->getValue(Args
);
1368 else if (A
->getOption().matches(OPT_iwithprefix
))
1369 Opts
.AddPath(Prefix
.str() + A
->getValue(Args
),
1370 frontend::System
, false, false, false);
1372 Opts
.AddPath(Prefix
.str() + A
->getValue(Args
),
1373 frontend::Angled
, false, false, false);
1376 for (arg_iterator it
= Args
.filtered_begin(OPT_idirafter
),
1377 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1378 Opts
.AddPath((*it
)->getValue(Args
), frontend::After
, true, false, false);
1379 for (arg_iterator it
= Args
.filtered_begin(OPT_iquote
),
1380 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1381 Opts
.AddPath((*it
)->getValue(Args
), frontend::Quoted
, true, false, false);
1382 for (arg_iterator it
= Args
.filtered_begin(OPT_cxx_isystem
, OPT_isystem
,
1383 OPT_iwithsysroot
), ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1384 Opts
.AddPath((*it
)->getValue(Args
),
1385 ((*it
)->getOption().matches(OPT_cxx_isystem
) ?
1386 frontend::CXXSystem
: frontend::System
),
1387 true, false, !(*it
)->getOption().matches(OPT_iwithsysroot
));
1389 // FIXME: Need options for the various environment variables!
1392 void CompilerInvocation::setLangDefaults(LangOptions
&Opts
, InputKind IK
,
1393 LangStandard::Kind LangStd
) {
1394 // Set some properties which depend solely on the input kind; it would be nice
1395 // to move these to the language standard, and have the driver resolve the
1396 // input kind + language standard.
1398 Opts
.AsmPreprocessor
= 1;
1399 } else if (IK
== IK_ObjC
||
1401 IK
== IK_PreprocessedObjC
||
1402 IK
== IK_PreprocessedObjCXX
) {
1403 Opts
.ObjC1
= Opts
.ObjC2
= 1;
1406 if (LangStd
== LangStandard::lang_unspecified
) {
1407 // Based on the base language, pick one.
1412 assert(0 && "Invalid input kind!");
1414 LangStd
= LangStandard::lang_opencl
;
1417 LangStd
= LangStandard::lang_cuda
;
1421 case IK_PreprocessedC
:
1423 case IK_PreprocessedObjC
:
1424 LangStd
= LangStandard::lang_gnu99
;
1427 case IK_PreprocessedCXX
:
1429 case IK_PreprocessedObjCXX
:
1430 LangStd
= LangStandard::lang_gnucxx98
;
1435 const LangStandard
&Std
= LangStandard::getLangStandardForKind(LangStd
);
1436 Opts
.BCPLComment
= Std
.hasBCPLComments();
1437 Opts
.C99
= Std
.isC99();
1438 Opts
.C1X
= Std
.isC1X();
1439 Opts
.CPlusPlus
= Std
.isCPlusPlus();
1440 Opts
.CPlusPlus0x
= Std
.isCPlusPlus0x();
1441 Opts
.Digraphs
= Std
.hasDigraphs();
1442 Opts
.GNUMode
= Std
.isGNUMode();
1443 Opts
.GNUInline
= !Std
.isC99();
1444 Opts
.HexFloats
= Std
.hasHexFloats();
1445 Opts
.ImplicitInt
= Std
.hasImplicitInt();
1447 // OpenCL has some additional defaults.
1448 if (LangStd
== LangStandard::lang_opencl
) {
1451 Opts
.CXXOperatorNames
= 1;
1452 Opts
.LaxVectorConversions
= 1;
1453 Opts
.DefaultFPContract
= 1;
1456 if (LangStd
== LangStandard::lang_cuda
)
1459 // OpenCL and C++ both have bool, true, false keywords.
1460 Opts
.Bool
= Opts
.OpenCL
|| Opts
.CPlusPlus
;
1462 Opts
.GNUKeywords
= Opts
.GNUMode
;
1463 Opts
.CXXOperatorNames
= Opts
.CPlusPlus
;
1465 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1466 // is specified, or -std is set to a conforming mode.
1467 Opts
.Trigraphs
= !Opts
.GNUMode
;
1469 Opts
.DollarIdents
= !Opts
.AsmPreprocessor
;
1472 static void ParseLangArgs(LangOptions
&Opts
, ArgList
&Args
, InputKind IK
,
1473 Diagnostic
&Diags
) {
1474 // FIXME: Cleanup per-file based stuff.
1475 LangStandard::Kind LangStd
= LangStandard::lang_unspecified
;
1476 if (const Arg
*A
= Args
.getLastArg(OPT_std_EQ
)) {
1477 LangStd
= llvm::StringSwitch
<LangStandard::Kind
>(A
->getValue(Args
))
1478 #define LANGSTANDARD(id, name, desc, features) \
1479 .Case(name, LangStandard::lang_##id)
1480 #include "clang/Frontend/LangStandards.def"
1481 .Default(LangStandard::lang_unspecified
);
1482 if (LangStd
== LangStandard::lang_unspecified
)
1483 Diags
.Report(diag::err_drv_invalid_value
)
1484 << A
->getAsString(Args
) << A
->getValue(Args
);
1486 // Valid standard, check to make sure language and standard are compatable.
1487 const LangStandard
&Std
= LangStandard::getLangStandardForKind(LangStd
);
1491 case IK_PreprocessedC
:
1492 case IK_PreprocessedObjC
:
1493 if (!(Std
.isC89() || Std
.isC99()))
1494 Diags
.Report(diag::err_drv_argument_not_allowed_with
)
1495 << A
->getAsString(Args
) << "C/ObjC";
1499 case IK_PreprocessedCXX
:
1500 case IK_PreprocessedObjCXX
:
1501 if (!Std
.isCPlusPlus())
1502 Diags
.Report(diag::err_drv_argument_not_allowed_with
)
1503 << A
->getAsString(Args
) << "C++/ObjC++";
1507 Diags
.Report(diag::err_drv_argument_not_allowed_with
)
1508 << A
->getAsString(Args
) << "OpenCL";
1511 if (!Std
.isCPlusPlus())
1512 Diags
.Report(diag::err_drv_argument_not_allowed_with
)
1513 << A
->getAsString(Args
) << "CUDA";
1521 if (const Arg
*A
= Args
.getLastArg(OPT_cl_std_EQ
)) {
1522 if (strcmp(A
->getValue(Args
), "CL1.1") != 0) {
1523 Diags
.Report(diag::err_drv_invalid_value
)
1524 << A
->getAsString(Args
) << A
->getValue(Args
);
1528 CompilerInvocation::setLangDefaults(Opts
, IK
, LangStd
);
1530 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1531 // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1532 // while a subset (the non-C++ GNU keywords) is provided by GCC's
1533 // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1534 // name, as it doesn't seem a useful distinction.
1535 Opts
.GNUKeywords
= Args
.hasFlag(OPT_fgnu_keywords
, OPT_fno_gnu_keywords
,
1538 if (Args
.hasArg(OPT_fno_operator_names
))
1539 Opts
.CXXOperatorNames
= 0;
1542 if (Args
.hasArg(OPT_fobjc_gc_only
))
1543 Opts
.setGCMode(LangOptions::GCOnly
);
1544 else if (Args
.hasArg(OPT_fobjc_gc
))
1545 Opts
.setGCMode(LangOptions::HybridGC
);
1546 else if (Args
.hasArg(OPT_fobjc_arc
)) {
1547 Opts
.ObjCAutoRefCount
= 1;
1548 if (!Args
.hasArg(OPT_fobjc_nonfragile_abi
))
1549 Diags
.Report(diag::err_arc_nonfragile_abi
);
1552 if (Args
.hasArg(OPT_fobjc_runtime_has_weak
))
1553 Opts
.ObjCRuntimeHasWeak
= 1;
1555 if (Args
.hasArg(OPT_fno_objc_infer_related_result_type
))
1556 Opts
.ObjCInferRelatedResultType
= 0;
1559 if (Args
.hasArg(OPT_fgnu89_inline
))
1562 if (Args
.hasArg(OPT_fapple_kext
)) {
1563 if (!Opts
.CPlusPlus
)
1564 Diags
.Report(diag::warn_c_kext
);
1569 if (Args
.hasArg(OPT_print_ivar_layout
))
1570 Opts
.ObjCGCBitmapPrint
= 1;
1571 if (Args
.hasArg(OPT_fno_constant_cfstrings
))
1572 Opts
.NoConstantCFStrings
= 1;
1574 if (Args
.hasArg(OPT_faltivec
))
1577 if (Args
.hasArg(OPT_pthread
))
1578 Opts
.POSIXThreads
= 1;
1580 if (Args
.hasArg(OPT_fdelayed_template_parsing
))
1581 Opts
.DelayedTemplateParsing
= 1;
1583 llvm::StringRef Vis
= Args
.getLastArgValue(OPT_fvisibility
, "default");
1584 if (Vis
== "default")
1585 Opts
.setVisibilityMode(DefaultVisibility
);
1586 else if (Vis
== "hidden")
1587 Opts
.setVisibilityMode(HiddenVisibility
);
1588 else if (Vis
== "protected")
1589 Opts
.setVisibilityMode(ProtectedVisibility
);
1591 Diags
.Report(diag::err_drv_invalid_value
)
1592 << Args
.getLastArg(OPT_fvisibility
)->getAsString(Args
) << Vis
;
1594 if (Args
.hasArg(OPT_fvisibility_inlines_hidden
))
1595 Opts
.InlineVisibilityHidden
= 1;
1597 if (Args
.hasArg(OPT_ftrapv
)) {
1598 Opts
.setSignedOverflowBehavior(LangOptions::SOB_Trapping
);
1599 // Set the handler, if one is specified.
1600 Opts
.OverflowHandler
=
1601 Args
.getLastArgValue(OPT_ftrapv_handler
);
1603 else if (Args
.hasArg(OPT_fwrapv
))
1604 Opts
.setSignedOverflowBehavior(LangOptions::SOB_Defined
);
1606 if (Args
.hasArg(OPT_trigraphs
))
1609 Opts
.DollarIdents
= Args
.hasFlag(OPT_fdollars_in_identifiers
,
1610 OPT_fno_dollars_in_identifiers
,
1612 Opts
.PascalStrings
= Args
.hasArg(OPT_fpascal_strings
);
1613 Opts
.Microsoft
= Args
.hasArg(OPT_fms_extensions
);
1614 Opts
.MSCVersion
= Args
.getLastArgIntValue(OPT_fmsc_version
, 0, Diags
);
1615 Opts
.Borland
= Args
.hasArg(OPT_fborland_extensions
);
1616 Opts
.WritableStrings
= Args
.hasArg(OPT_fwritable_strings
);
1617 Opts
.ConstStrings
= Args
.hasFlag(OPT_fconst_strings
, OPT_fno_const_strings
,
1619 if (Args
.hasArg(OPT_fno_lax_vector_conversions
))
1620 Opts
.LaxVectorConversions
= 0;
1621 if (Args
.hasArg(OPT_fno_threadsafe_statics
))
1622 Opts
.ThreadsafeStatics
= 0;
1623 Opts
.Exceptions
= Args
.hasArg(OPT_fexceptions
);
1624 Opts
.ObjCExceptions
= Args
.hasArg(OPT_fobjc_exceptions
);
1625 Opts
.CXXExceptions
= Args
.hasArg(OPT_fcxx_exceptions
);
1626 Opts
.SjLjExceptions
= Args
.hasArg(OPT_fsjlj_exceptions
);
1627 Opts
.TraditionalCPP
= Args
.hasArg(OPT_traditional_cpp
);
1629 Opts
.RTTI
= !Args
.hasArg(OPT_fno_rtti
);
1630 Opts
.Blocks
= Args
.hasArg(OPT_fblocks
);
1631 Opts
.CharIsSigned
= !Args
.hasArg(OPT_fno_signed_char
);
1632 Opts
.ShortWChar
= Args
.hasArg(OPT_fshort_wchar
);
1633 Opts
.ShortEnums
= Args
.hasArg(OPT_fshort_enums
);
1634 Opts
.Freestanding
= Args
.hasArg(OPT_ffreestanding
);
1635 Opts
.NoBuiltin
= Args
.hasArg(OPT_fno_builtin
) || Opts
.Freestanding
;
1636 Opts
.AssumeSaneOperatorNew
= !Args
.hasArg(OPT_fno_assume_sane_operator_new
);
1637 Opts
.HeinousExtensions
= Args
.hasArg(OPT_fheinous_gnu_extensions
);
1638 Opts
.AccessControl
= !Args
.hasArg(OPT_fno_access_control
);
1639 Opts
.ElideConstructors
= !Args
.hasArg(OPT_fno_elide_constructors
);
1640 Opts
.MathErrno
= Args
.hasArg(OPT_fmath_errno
);
1641 Opts
.InstantiationDepth
= Args
.getLastArgIntValue(OPT_ftemplate_depth
, 1024,
1643 Opts
.DelayedTemplateParsing
= Args
.hasArg(OPT_fdelayed_template_parsing
);
1644 Opts
.NumLargeByValueCopy
= Args
.getLastArgIntValue(OPT_Wlarge_by_value_copy
,
1646 Opts
.MSBitfields
= Args
.hasArg(OPT_mms_bitfields
);
1647 Opts
.NeXTRuntime
= !Args
.hasArg(OPT_fgnu_runtime
);
1648 Opts
.ObjCConstantStringClass
=
1649 Args
.getLastArgValue(OPT_fconstant_string_class
);
1650 Opts
.ObjCNonFragileABI
= Args
.hasArg(OPT_fobjc_nonfragile_abi
);
1651 if (Opts
.ObjCNonFragileABI
)
1652 Opts
.ObjCNonFragileABI2
= true;
1653 Opts
.ObjCDefaultSynthProperties
=
1654 Args
.hasArg(OPT_fobjc_default_synthesize_properties
);
1655 Opts
.CatchUndefined
= Args
.hasArg(OPT_fcatch_undefined_behavior
);
1656 Opts
.EmitAllDecls
= Args
.hasArg(OPT_femit_all_decls
);
1657 Opts
.PICLevel
= Args
.getLastArgIntValue(OPT_pic_level
, 0, Diags
);
1658 Opts
.Static
= Args
.hasArg(OPT_static_define
);
1659 Opts
.DumpRecordLayouts
= Args
.hasArg(OPT_fdump_record_layouts
);
1660 Opts
.DumpVTableLayouts
= Args
.hasArg(OPT_fdump_vtable_layouts
);
1661 Opts
.SpellChecking
= !Args
.hasArg(OPT_fno_spell_checking
);
1662 Opts
.NoBitFieldTypeAlign
= Args
.hasArg(OPT_fno_bitfield_type_align
);
1663 Opts
.SinglePrecisionConstants
= Args
.hasArg(OPT_cl_single_precision_constant
);
1664 Opts
.FastRelaxedMath
= Args
.hasArg(OPT_cl_fast_relaxed_math
);
1665 Opts
.OptimizeSize
= 0;
1666 Opts
.MRTD
= Args
.hasArg(OPT_mrtd
);
1667 Opts
.FakeAddressSpaceMap
= Args
.hasArg(OPT_ffake_address_space_map
);
1668 Opts
.ParseUnknownAnytype
= Args
.hasArg(OPT_funknown_anytype
);
1670 // Record whether the __DEPRECATED define was requested.
1671 Opts
.Deprecated
= Args
.hasFlag(OPT_fdeprecated_macro
,
1672 OPT_fno_deprecated_macro
,
1675 // FIXME: Eliminate this dependency.
1676 unsigned Opt
= getOptimizationLevel(Args
, IK
, Diags
);
1677 Opts
.Optimize
= Opt
!= 0;
1679 // This is the __NO_INLINE__ define, which just depends on things like the
1680 // optimization level and -fno-inline, not actually whether the backend has
1681 // inlining enabled.
1683 // FIXME: This is affected by other options (-fno-inline).
1684 Opts
.NoInline
= !Opt
;
1686 unsigned SSP
= Args
.getLastArgIntValue(OPT_stack_protector
, 0, Diags
);
1689 Diags
.Report(diag::err_drv_invalid_value
)
1690 << Args
.getLastArg(OPT_stack_protector
)->getAsString(Args
) << SSP
;
1692 case 0: Opts
.setStackProtectorMode(LangOptions::SSPOff
); break;
1693 case 1: Opts
.setStackProtectorMode(LangOptions::SSPOn
); break;
1694 case 2: Opts
.setStackProtectorMode(LangOptions::SSPReq
); break;
1698 static void ParsePreprocessorArgs(PreprocessorOptions
&Opts
, ArgList
&Args
,
1699 FileManager
&FileMgr
,
1700 Diagnostic
&Diags
) {
1701 using namespace cc1options
;
1702 Opts
.ImplicitPCHInclude
= Args
.getLastArgValue(OPT_include_pch
);
1703 Opts
.ImplicitPTHInclude
= Args
.getLastArgValue(OPT_include_pth
);
1704 if (const Arg
*A
= Args
.getLastArg(OPT_token_cache
))
1705 Opts
.TokenCache
= A
->getValue(Args
);
1707 Opts
.TokenCache
= Opts
.ImplicitPTHInclude
;
1708 Opts
.UsePredefines
= !Args
.hasArg(OPT_undef
);
1709 Opts
.DetailedRecord
= Args
.hasArg(OPT_detailed_preprocessing_record
);
1710 Opts
.DisablePCHValidation
= Args
.hasArg(OPT_fno_validate_pch
);
1712 Opts
.DumpDeserializedPCHDecls
= Args
.hasArg(OPT_dump_deserialized_pch_decls
);
1713 for (arg_iterator it
= Args
.filtered_begin(OPT_error_on_deserialized_pch_decl
),
1714 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1716 Opts
.DeserializedPCHDeclsToErrorOn
.insert(A
->getValue(Args
));
1719 if (const Arg
*A
= Args
.getLastArg(OPT_preamble_bytes_EQ
)) {
1720 llvm::StringRef
Value(A
->getValue(Args
));
1721 size_t Comma
= Value
.find(',');
1723 unsigned EndOfLine
= 0;
1725 if (Comma
== llvm::StringRef::npos
||
1726 Value
.substr(0, Comma
).getAsInteger(10, Bytes
) ||
1727 Value
.substr(Comma
+ 1).getAsInteger(10, EndOfLine
))
1728 Diags
.Report(diag::err_drv_preamble_format
);
1730 Opts
.PrecompiledPreambleBytes
.first
= Bytes
;
1731 Opts
.PrecompiledPreambleBytes
.second
= (EndOfLine
!= 0);
1735 // Add macros from the command line.
1736 for (arg_iterator it
= Args
.filtered_begin(OPT_D
, OPT_U
),
1737 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1738 if ((*it
)->getOption().matches(OPT_D
))
1739 Opts
.addMacroDef((*it
)->getValue(Args
));
1741 Opts
.addMacroUndef((*it
)->getValue(Args
));
1744 Opts
.MacroIncludes
= Args
.getAllArgValues(OPT_imacros
);
1746 // Add the ordered list of -includes.
1747 for (arg_iterator it
= Args
.filtered_begin(OPT_include
, OPT_include_pch
,
1749 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1751 // PCH is handled specially, we need to extra the original include path.
1752 if (A
->getOption().matches(OPT_include_pch
)) {
1753 std::string OriginalFile
=
1754 ASTReader::getOriginalSourceFile(A
->getValue(Args
), FileMgr
, Diags
);
1755 if (OriginalFile
.empty())
1758 Opts
.Includes
.push_back(OriginalFile
);
1760 Opts
.Includes
.push_back(A
->getValue(Args
));
1763 for (arg_iterator it
= Args
.filtered_begin(OPT_chain_include
),
1764 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1766 Opts
.ChainedIncludes
.push_back(A
->getValue(Args
));
1769 // Include 'altivec.h' if -faltivec option present
1770 if (Args
.hasArg(OPT_faltivec
))
1771 Opts
.Includes
.push_back("altivec.h");
1773 for (arg_iterator it
= Args
.filtered_begin(OPT_remap_file
),
1774 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1776 std::pair
<llvm::StringRef
,llvm::StringRef
> Split
=
1777 llvm::StringRef(A
->getValue(Args
)).split(';');
1779 if (Split
.second
.empty()) {
1780 Diags
.Report(diag::err_drv_invalid_remap_file
) << A
->getAsString(Args
);
1784 Opts
.addRemappedFile(Split
.first
, Split
.second
);
1787 if (Arg
*A
= Args
.getLastArg(OPT_fobjc_arc_cxxlib_EQ
)) {
1788 llvm::StringRef Name
= A
->getValue(Args
);
1789 unsigned Library
= llvm::StringSwitch
<unsigned>(Name
)
1790 .Case("libc++", ARCXX_libcxx
)
1791 .Case("libstdc++", ARCXX_libstdcxx
)
1792 .Case("none", ARCXX_nolib
)
1795 Diags
.Report(diag::err_drv_invalid_value
) << A
->getAsString(Args
) << Name
;
1797 Opts
.ObjCXXARCStandardLibrary
= (ObjCXXARCStandardLibraryKind
)Library
;
1801 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions
&Opts
,
1803 using namespace cc1options
;
1804 Opts
.ShowCPP
= !Args
.hasArg(OPT_dM
);
1805 Opts
.ShowComments
= Args
.hasArg(OPT_C
);
1806 Opts
.ShowLineMarkers
= !Args
.hasArg(OPT_P
);
1807 Opts
.ShowMacroComments
= Args
.hasArg(OPT_CC
);
1808 Opts
.ShowMacros
= Args
.hasArg(OPT_dM
) || Args
.hasArg(OPT_dD
);
1811 static void ParseTargetArgs(TargetOptions
&Opts
, ArgList
&Args
) {
1812 using namespace cc1options
;
1813 Opts
.ABI
= Args
.getLastArgValue(OPT_target_abi
);
1814 Opts
.CXXABI
= Args
.getLastArgValue(OPT_cxx_abi
);
1815 Opts
.CPU
= Args
.getLastArgValue(OPT_target_cpu
);
1816 Opts
.Features
= Args
.getAllArgValues(OPT_target_feature
);
1817 Opts
.LinkerVersion
= Args
.getLastArgValue(OPT_target_linker_version
);
1818 Opts
.Triple
= llvm::Triple::normalize(Args
.getLastArgValue(OPT_triple
));
1820 // Use the host triple if unspecified.
1821 if (Opts
.Triple
.empty())
1822 Opts
.Triple
= llvm::sys::getHostTriple();
1827 void CompilerInvocation::CreateFromArgs(CompilerInvocation
&Res
,
1828 const char *const *ArgBegin
,
1829 const char *const *ArgEnd
,
1830 Diagnostic
&Diags
) {
1831 // Parse the arguments.
1832 llvm::OwningPtr
<OptTable
> Opts(createCC1OptTable());
1833 unsigned MissingArgIndex
, MissingArgCount
;
1834 llvm::OwningPtr
<InputArgList
> Args(
1835 Opts
->ParseArgs(ArgBegin
, ArgEnd
,MissingArgIndex
, MissingArgCount
));
1837 // Check for missing argument error.
1838 if (MissingArgCount
)
1839 Diags
.Report(diag::err_drv_missing_argument
)
1840 << Args
->getArgString(MissingArgIndex
) << MissingArgCount
;
1842 // Issue errors on unknown arguments.
1843 for (arg_iterator it
= Args
->filtered_begin(OPT_UNKNOWN
),
1844 ie
= Args
->filtered_end(); it
!= ie
; ++it
)
1845 Diags
.Report(diag::err_drv_unknown_argument
) << (*it
)->getAsString(*Args
);
1847 ParseAnalyzerArgs(Res
.getAnalyzerOpts(), *Args
, Diags
);
1848 ParseDependencyOutputArgs(Res
.getDependencyOutputOpts(), *Args
);
1849 ParseDiagnosticArgs(Res
.getDiagnosticOpts(), *Args
, Diags
);
1850 ParseFileSystemArgs(Res
.getFileSystemOpts(), *Args
);
1851 // FIXME: We shouldn't have to pass the DashX option around here
1852 InputKind DashX
= ParseFrontendArgs(Res
.getFrontendOpts(), *Args
, Diags
);
1853 ParseCodeGenArgs(Res
.getCodeGenOpts(), *Args
, DashX
, Diags
);
1854 ParseHeaderSearchArgs(Res
.getHeaderSearchOpts(), *Args
);
1855 if (DashX
!= IK_AST
&& DashX
!= IK_LLVM_IR
) {
1856 ParseLangArgs(Res
.getLangOpts(), *Args
, DashX
, Diags
);
1857 if (Res
.getFrontendOpts().ProgramAction
== frontend::RewriteObjC
)
1858 Res
.getLangOpts().ObjCExceptions
= 1;
1860 // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
1861 // PCH file and find the original header name. Remove the need to do that in
1862 // ParsePreprocessorArgs and remove the FileManager
1863 // parameters from the function and the "FileManager.h" #include.
1864 FileManager
FileMgr(Res
.getFileSystemOpts());
1865 ParsePreprocessorArgs(Res
.getPreprocessorOpts(), *Args
, FileMgr
, Diags
);
1866 ParsePreprocessorOutputArgs(Res
.getPreprocessorOutputOpts(), *Args
);
1867 ParseTargetArgs(Res
.getTargetOpts(), *Args
);