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 *getAnalysisName(Analyses Kind
) {
36 llvm_unreachable("Unknown analysis kind!");
37 #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE)\
38 case NAME: return "-" CMDFLAG;
39 #include "clang/Frontend/Analyses.def"
43 static const char *getAnalysisStoreName(AnalysisStores Kind
) {
46 llvm_unreachable("Unknown analysis store!");
47 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
48 case NAME##Model: return CMDFLAG;
49 #include "clang/Frontend/Analyses.def"
53 static const char *getAnalysisConstraintName(AnalysisConstraints Kind
) {
56 llvm_unreachable("Unknown analysis constraints!");
57 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
58 case NAME##Model: return CMDFLAG;
59 #include "clang/Frontend/Analyses.def"
63 static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind
) {
66 llvm_unreachable("Unknown analysis client!");
67 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
68 case PD_##NAME: return CMDFLAG;
69 #include "clang/Frontend/Analyses.def"
73 //===----------------------------------------------------------------------===//
74 // Serialization (to args)
75 //===----------------------------------------------------------------------===//
77 static void AnalyzerOptsToArgs(const AnalyzerOptions
&Opts
,
78 std::vector
<std::string
> &Res
) {
79 for (unsigned i
= 0, e
= Opts
.AnalysisList
.size(); i
!= e
; ++i
)
80 Res
.push_back(getAnalysisName(Opts
.AnalysisList
[i
]));
81 if (Opts
.AnalysisStoreOpt
!= BasicStoreModel
) {
82 Res
.push_back("-analyzer-store");
83 Res
.push_back(getAnalysisStoreName(Opts
.AnalysisStoreOpt
));
85 if (Opts
.AnalysisConstraintsOpt
!= RangeConstraintsModel
) {
86 Res
.push_back("-analyzer-constraints");
87 Res
.push_back(getAnalysisConstraintName(Opts
.AnalysisConstraintsOpt
));
89 if (Opts
.AnalysisDiagOpt
!= PD_HTML
) {
90 Res
.push_back("-analyzer-output");
91 Res
.push_back(getAnalysisDiagClientName(Opts
.AnalysisDiagOpt
));
93 if (!Opts
.AnalyzeSpecificFunction
.empty()) {
94 Res
.push_back("-analyze-function");
95 Res
.push_back(Opts
.AnalyzeSpecificFunction
);
98 Res
.push_back("-analyzer-opt-analyze-headers");
99 if (Opts
.AnalyzerDisplayProgress
)
100 Res
.push_back("-analyzer-display-progress");
101 if (Opts
.AnalyzeNestedBlocks
)
102 Res
.push_back("-analyzer-opt-analyze-nested-blocks");
103 if (Opts
.AnalyzerStats
)
104 Res
.push_back("-analyzer-stats");
105 if (Opts
.EagerlyAssume
)
106 Res
.push_back("-analyzer-eagerly-assume");
108 Res
.push_back("-analyzer-no-purge-dead");
110 Res
.push_back("-trim-egraph");
111 if (Opts
.VisualizeEGDot
)
112 Res
.push_back("-analyzer-viz-egraph-graphviz");
113 if (Opts
.VisualizeEGDot
)
114 Res
.push_back("-analyzer-viz-egraph-ubigraph");
115 if (Opts
.EnableExperimentalChecks
)
116 Res
.push_back("-analyzer-experimental-checks");
117 if (Opts
.EnableExperimentalInternalChecks
)
118 Res
.push_back("-analyzer-experimental-internal-checks");
119 if (Opts
.IdempotentOps
)
120 Res
.push_back("-analyzer-check-idempotent-operations");
123 static void CodeGenOptsToArgs(const CodeGenOptions
&Opts
,
124 std::vector
<std::string
> &Res
) {
127 if (Opts
.DisableLLVMOpts
)
128 Res
.push_back("-disable-llvm-optzns");
129 if (Opts
.DisableRedZone
)
130 Res
.push_back("-disable-red-zone");
131 if (!Opts
.DwarfDebugFlags
.empty()) {
132 Res
.push_back("-dwarf-debug-flags");
133 Res
.push_back(Opts
.DwarfDebugFlags
);
135 if (!Opts
.MergeAllConstants
)
136 Res
.push_back("-fno-merge-all-constants");
138 Res
.push_back("-fno-common");
139 if (Opts
.NoImplicitFloat
)
140 Res
.push_back("-no-implicit-float");
141 if (Opts
.OmitLeafFramePointer
)
142 Res
.push_back("-momit-leaf-frame-pointer");
143 if (Opts
.OptimizeSize
) {
144 assert(Opts
.OptimizationLevel
== 2 && "Invalid options!");
145 Res
.push_back("-Os");
146 } else if (Opts
.OptimizationLevel
!= 0)
147 Res
.push_back("-O" + llvm::utostr(Opts
.OptimizationLevel
));
148 if (!Opts
.MainFileName
.empty()) {
149 Res
.push_back("-main-file-name");
150 Res
.push_back(Opts
.MainFileName
);
152 // SimplifyLibCalls is only derived.
153 // TimePasses is only derived.
154 // UnitAtATime is unused.
155 // Inlining is only derived.
157 // UnrollLoops is derived, but also accepts an option, no
158 // harm in pushing it back here.
159 if (Opts
.UnrollLoops
)
160 Res
.push_back("-funroll-loops");
161 if (Opts
.DataSections
)
162 Res
.push_back("-fdata-sections");
163 if (Opts
.FunctionSections
)
164 Res
.push_back("-ffunction-sections");
166 Res
.push_back("-masm-verbose");
167 if (!Opts
.CodeModel
.empty()) {
168 Res
.push_back("-mcode-model");
169 Res
.push_back(Opts
.CodeModel
);
172 Res
.push_back("-fno-use-cxa-atexit");
173 if (Opts
.CXXCtorDtorAliases
)
174 Res
.push_back("-mconstructor-aliases");
175 if (!Opts
.DebugPass
.empty()) {
176 Res
.push_back("-mdebug-pass");
177 Res
.push_back(Opts
.DebugPass
);
179 if (Opts
.DisableFPElim
)
180 Res
.push_back("-mdisable-fp-elim");
181 if (!Opts
.FloatABI
.empty()) {
182 Res
.push_back("-mfloat-abi");
183 Res
.push_back(Opts
.FloatABI
);
185 if (!Opts
.LimitFloatPrecision
.empty()) {
186 Res
.push_back("-mlimit-float-precision");
187 Res
.push_back(Opts
.LimitFloatPrecision
);
189 if (Opts
.NoZeroInitializedInBSS
)
190 Res
.push_back("-mno-zero-initialized-bss");
191 switch (Opts
.getObjCDispatchMethod()) {
192 case CodeGenOptions::Legacy
:
194 case CodeGenOptions::Mixed
:
195 Res
.push_back("-fobjc-dispatch-method=mixed");
197 case CodeGenOptions::NonLegacy
:
198 Res
.push_back("-fobjc-dispatch-method=non-legacy");
202 Res
.push_back("-mrelax-all");
204 Res
.push_back("-msoft-float");
205 if (Opts
.UnwindTables
)
206 Res
.push_back("-munwind-tables");
207 if (Opts
.RelocationModel
!= "pic") {
208 Res
.push_back("-mrelocation-model");
209 Res
.push_back(Opts
.RelocationModel
);
211 if (!Opts
.VerifyModule
)
212 Res
.push_back("-disable-llvm-verifier");
215 static void DependencyOutputOptsToArgs(const DependencyOutputOptions
&Opts
,
216 std::vector
<std::string
> &Res
) {
217 if (Opts
.IncludeSystemHeaders
)
218 Res
.push_back("-sys-header-deps");
219 if (Opts
.UsePhonyTargets
)
220 Res
.push_back("-MP");
221 if (!Opts
.OutputFile
.empty()) {
222 Res
.push_back("-dependency-file");
223 Res
.push_back(Opts
.OutputFile
);
225 for (unsigned i
= 0, e
= Opts
.Targets
.size(); i
!= e
; ++i
) {
226 Res
.push_back("-MT");
227 Res
.push_back(Opts
.Targets
[i
]);
231 static void DiagnosticOptsToArgs(const DiagnosticOptions
&Opts
,
232 std::vector
<std::string
> &Res
) {
233 if (Opts
.IgnoreWarnings
)
235 if (Opts
.NoRewriteMacros
)
236 Res
.push_back("-Wno-rewrite-macros");
238 Res
.push_back("-pedantic");
239 if (Opts
.PedanticErrors
)
240 Res
.push_back("-pedantic-errors");
241 if (!Opts
.ShowColumn
)
242 Res
.push_back("-fno-show-column");
243 if (!Opts
.ShowLocation
)
244 Res
.push_back("-fno-show-source-location");
245 if (!Opts
.ShowCarets
)
246 Res
.push_back("-fno-caret-diagnostics");
247 if (!Opts
.ShowFixits
)
248 Res
.push_back("-fno-diagnostics-fixit-info");
249 if (Opts
.ShowSourceRanges
)
250 Res
.push_back("-fdiagnostics-print-source-range-info");
251 if (Opts
.ShowParseableFixits
)
252 Res
.push_back("-fdiagnostics-parseable-fixits");
254 Res
.push_back("-fcolor-diagnostics");
255 if (Opts
.VerifyDiagnostics
)
256 Res
.push_back("-verify");
257 if (Opts
.ShowOptionNames
)
258 Res
.push_back("-fdiagnostics-show-option");
259 if (Opts
.ShowCategories
== 1)
260 Res
.push_back("-fdiagnostics-show-category=id");
261 else if (Opts
.ShowCategories
== 2)
262 Res
.push_back("-fdiagnostics-show-category=name");
263 if (Opts
.ErrorLimit
) {
264 Res
.push_back("-ferror-limit");
265 Res
.push_back(llvm::utostr(Opts
.ErrorLimit
));
267 if (Opts
.MacroBacktraceLimit
268 != DiagnosticOptions::DefaultMacroBacktraceLimit
) {
269 Res
.push_back("-fmacro-backtrace-limit");
270 Res
.push_back(llvm::utostr(Opts
.MacroBacktraceLimit
));
272 if (Opts
.TemplateBacktraceLimit
273 != DiagnosticOptions::DefaultTemplateBacktraceLimit
) {
274 Res
.push_back("-ftemplate-backtrace-limit");
275 Res
.push_back(llvm::utostr(Opts
.TemplateBacktraceLimit
));
278 if (Opts
.TabStop
!= DiagnosticOptions::DefaultTabStop
) {
279 Res
.push_back("-ftabstop");
280 Res
.push_back(llvm::utostr(Opts
.TabStop
));
282 if (Opts
.MessageLength
) {
283 Res
.push_back("-fmessage-length");
284 Res
.push_back(llvm::utostr(Opts
.MessageLength
));
286 if (!Opts
.DumpBuildInformation
.empty()) {
287 Res
.push_back("-dump-build-information");
288 Res
.push_back(Opts
.DumpBuildInformation
);
290 for (unsigned i
= 0, e
= Opts
.Warnings
.size(); i
!= e
; ++i
)
291 Res
.push_back("-W" + Opts
.Warnings
[i
]);
294 static const char *getInputKindName(InputKind Kind
) {
297 case IK_AST
: return "ast";
298 case IK_Asm
: return "assembler-with-cpp";
299 case IK_C
: return "c";
300 case IK_CXX
: return "c++";
301 case IK_LLVM_IR
: return "ir";
302 case IK_ObjC
: return "objective-c";
303 case IK_ObjCXX
: return "objective-c++";
304 case IK_OpenCL
: return "cl";
305 case IK_CUDA
: return "cuda";
306 case IK_PreprocessedC
: return "cpp-output";
307 case IK_PreprocessedCXX
: return "c++-cpp-output";
308 case IK_PreprocessedObjC
: return "objective-c-cpp-output";
309 case IK_PreprocessedObjCXX
:return "objective-c++-cpp-output";
312 llvm_unreachable("Unexpected language kind!");
316 static const char *getActionName(frontend::ActionKind Kind
) {
318 case frontend::PluginAction
:
319 case frontend::InheritanceView
:
320 llvm_unreachable("Invalid kind!");
322 case frontend::ASTDump
: return "-ast-dump";
323 case frontend::ASTDumpXML
: return "-ast-dump-xml";
324 case frontend::ASTPrint
: return "-ast-print";
325 case frontend::ASTPrintXML
: return "-ast-print-xml";
326 case frontend::ASTView
: return "-ast-view";
327 case frontend::BoostCon
: return "-boostcon";
328 case frontend::CreateModule
: return "-create-module";
329 case frontend::DumpRawTokens
: return "-dump-raw-tokens";
330 case frontend::DumpTokens
: return "-dump-tokens";
331 case frontend::EmitAssembly
: return "-S";
332 case frontend::EmitBC
: return "-emit-llvm-bc";
333 case frontend::EmitHTML
: return "-emit-html";
334 case frontend::EmitLLVM
: return "-emit-llvm";
335 case frontend::EmitLLVMOnly
: return "-emit-llvm-only";
336 case frontend::EmitCodeGenOnly
: return "-emit-codegen-only";
337 case frontend::EmitObj
: return "-emit-obj";
338 case frontend::FixIt
: return "-fixit";
339 case frontend::GeneratePCH
: return "-emit-pch";
340 case frontend::GeneratePTH
: return "-emit-pth";
341 case frontend::InitOnly
: return "-init-only";
342 case frontend::ParseSyntaxOnly
: return "-fsyntax-only";
343 case frontend::PrintDeclContext
: return "-print-decl-contexts";
344 case frontend::PrintPreamble
: return "-print-preamble";
345 case frontend::PrintPreprocessedInput
: return "-E";
346 case frontend::RewriteMacros
: return "-rewrite-macros";
347 case frontend::RewriteObjC
: return "-rewrite-objc";
348 case frontend::RewriteTest
: return "-rewrite-test";
349 case frontend::RunAnalysis
: return "-analyze";
350 case frontend::RunPreprocessorOnly
: return "-Eonly";
353 llvm_unreachable("Unexpected language kind!");
357 static void FileSystemOptsToArgs(const FileSystemOptions
&Opts
,
358 std::vector
<std::string
> &Res
) {
359 if (!Opts
.WorkingDir
.empty()) {
360 Res
.push_back("-working-directory");
361 Res
.push_back(Opts
.WorkingDir
);
365 static void FrontendOptsToArgs(const FrontendOptions
&Opts
,
366 std::vector
<std::string
> &Res
) {
367 if (Opts
.DisableFree
)
368 Res
.push_back("-disable-free");
369 if (Opts
.RelocatablePCH
)
370 Res
.push_back("-relocatable-pch");
372 Res
.push_back("-chained-pch");
374 Res
.push_back("-help");
375 if (Opts
.ShowMacrosInCodeCompletion
)
376 Res
.push_back("-code-completion-macros");
377 if (Opts
.ShowCodePatternsInCodeCompletion
)
378 Res
.push_back("-code-completion-patterns");
379 if (!Opts
.ShowGlobalSymbolsInCodeCompletion
)
380 Res
.push_back("-no-code-completion-globals");
382 Res
.push_back("-print-stats");
384 Res
.push_back("-ftime-report");
385 if (Opts
.ShowVersion
)
386 Res
.push_back("-version");
387 if (Opts
.FixWhatYouCan
)
388 Res
.push_back("-fix-what-you-can");
390 bool NeedLang
= false;
391 for (unsigned i
= 0, e
= Opts
.Inputs
.size(); i
!= e
; ++i
)
392 if (FrontendOptions::getInputKindForExtension(Opts
.Inputs
[i
].second
) !=
393 Opts
.Inputs
[i
].first
)
397 Res
.push_back(getInputKindName(Opts
.Inputs
[0].first
));
399 for (unsigned i
= 0, e
= Opts
.Inputs
.size(); i
!= e
; ++i
) {
400 assert((!NeedLang
|| Opts
.Inputs
[i
].first
== Opts
.Inputs
[0].first
) &&
401 "Unable to represent this input vector!");
402 Res
.push_back(Opts
.Inputs
[i
].second
);
405 if (!Opts
.OutputFile
.empty()) {
407 Res
.push_back(Opts
.OutputFile
);
409 if (!Opts
.ViewClassInheritance
.empty()) {
410 Res
.push_back("-cxx-inheritance-view");
411 Res
.push_back(Opts
.ViewClassInheritance
);
413 if (!Opts
.CodeCompletionAt
.FileName
.empty()) {
414 Res
.push_back("-code-completion-at");
415 Res
.push_back(Opts
.CodeCompletionAt
.FileName
+ ":" +
416 llvm::utostr(Opts
.CodeCompletionAt
.Line
) + ":" +
417 llvm::utostr(Opts
.CodeCompletionAt
.Column
));
419 if (Opts
.ProgramAction
!= frontend::InheritanceView
&&
420 Opts
.ProgramAction
!= frontend::PluginAction
)
421 Res
.push_back(getActionName(Opts
.ProgramAction
));
422 if (!Opts
.ActionName
.empty()) {
423 Res
.push_back("-plugin");
424 Res
.push_back(Opts
.ActionName
);
425 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
]);
430 for (unsigned i
= 0, e
= Opts
.Plugins
.size(); i
!= e
; ++i
) {
431 Res
.push_back("-load");
432 Res
.push_back(Opts
.Plugins
[i
]);
434 for (unsigned i
= 0, e
= Opts
.ASTMergeFiles
.size(); i
!= e
; ++i
) {
435 Res
.push_back("-ast-merge");
436 Res
.push_back(Opts
.ASTMergeFiles
[i
]);
438 for (unsigned i
= 0, e
= Opts
.Modules
.size(); i
!= e
; ++i
) {
439 Res
.push_back("-import-module");
440 Res
.push_back(Opts
.Modules
[i
]);
442 for (unsigned i
= 0, e
= Opts
.LLVMArgs
.size(); i
!= e
; ++i
) {
443 Res
.push_back("-mllvm");
444 Res
.push_back(Opts
.LLVMArgs
[i
]);
448 static void HeaderSearchOptsToArgs(const HeaderSearchOptions
&Opts
,
449 std::vector
<std::string
> &Res
) {
450 if (Opts
.Sysroot
!= "/") {
451 Res
.push_back("-isysroot");
452 Res
.push_back(Opts
.Sysroot
);
455 for (unsigned i
= 0, e
= Opts
.CXXSystemIncludes
.size(); i
!= e
; ++i
) {
456 Res
.push_back("-cxx-system-include");
457 Res
.push_back(Opts
.CXXSystemIncludes
[i
]);
460 /// User specified include entries.
461 for (unsigned i
= 0, e
= Opts
.UserEntries
.size(); i
!= e
; ++i
) {
462 const HeaderSearchOptions::Entry
&E
= Opts
.UserEntries
[i
];
463 if (E
.IsFramework
&& (E
.Group
!= frontend::Angled
|| !E
.IsUserSupplied
))
464 llvm::report_fatal_error("Invalid option set!");
465 if (E
.IsUserSupplied
) {
466 if (E
.Group
== frontend::After
) {
467 Res
.push_back("-idirafter");
468 } else if (E
.Group
== frontend::Quoted
) {
469 Res
.push_back("-iquote");
470 } else if (E
.Group
== frontend::System
) {
471 Res
.push_back("-isystem");
473 assert(E
.Group
== frontend::Angled
&& "Invalid group!");
474 Res
.push_back(E
.IsFramework
? "-F" : "-I");
477 if (E
.Group
!= frontend::Angled
&& E
.Group
!= frontend::System
)
478 llvm::report_fatal_error("Invalid option set!");
479 Res
.push_back(E
.Group
== frontend::Angled
? "-iwithprefixbefore" :
482 Res
.push_back(E
.Path
);
485 if (!Opts
.EnvIncPath
.empty()) {
486 // FIXME: Provide an option for this, and move env detection to driver.
487 llvm::report_fatal_error("Not yet implemented!");
489 if (!Opts
.CEnvIncPath
.empty()) {
490 // FIXME: Provide an option for this, and move env detection to driver.
491 llvm::report_fatal_error("Not yet implemented!");
493 if (!Opts
.ObjCEnvIncPath
.empty()) {
494 // FIXME: Provide an option for this, and move env detection to driver.
495 llvm::report_fatal_error("Not yet implemented!");
497 if (!Opts
.CXXEnvIncPath
.empty()) {
498 // FIXME: Provide an option for this, and move env detection to driver.
499 llvm::report_fatal_error("Not yet implemented!");
501 if (!Opts
.ObjCXXEnvIncPath
.empty()) {
502 // FIXME: Provide an option for this, and move env detection to driver.
503 llvm::report_fatal_error("Not yet implemented!");
505 if (!Opts
.ResourceDir
.empty()) {
506 Res
.push_back("-resource-dir");
507 Res
.push_back(Opts
.ResourceDir
);
509 if (!Opts
.UseStandardIncludes
)
510 Res
.push_back("-nostdinc");
511 if (!Opts
.UseStandardCXXIncludes
)
512 Res
.push_back("-nostdinc++");
517 static void LangOptsToArgs(const LangOptions
&Opts
,
518 std::vector
<std::string
> &Res
) {
519 LangOptions DefaultLangOpts
;
521 // FIXME: Need to set -std to get all the implicit options.
523 // FIXME: We want to only pass options relative to the defaults, which
524 // requires constructing a target. :(
526 // It would be better to push the all target specific choices into the driver,
527 // so that everything below that was more uniform.
530 Res
.push_back("-trigraphs");
531 // Implicit based on the input kind:
532 // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
533 // Implicit based on the input language standard:
534 // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
535 if (Opts
.DollarIdents
)
536 Res
.push_back("-fdollars-in-identifiers");
537 if (Opts
.GNUMode
&& !Opts
.GNUKeywords
)
538 Res
.push_back("-fno-gnu-keywords");
539 if (!Opts
.GNUMode
&& Opts
.GNUKeywords
)
540 Res
.push_back("-fgnu-keywords");
542 Res
.push_back("-fms-extensions");
543 if (Opts
.MSCVersion
!= 0)
544 Res
.push_back("-fmsc-version=" + llvm::utostr(Opts
.MSCVersion
));
546 Res
.push_back("-fborland-extensions");
547 if (Opts
.ObjCNonFragileABI
)
548 Res
.push_back("-fobjc-nonfragile-abi");
549 if (Opts
.ObjCNonFragileABI2
)
550 Res
.push_back("-fobjc-nonfragile-abi2");
551 // NoInline is implicit.
552 if (!Opts
.CXXOperatorNames
)
553 Res
.push_back("-fno-operator-names");
554 if (Opts
.PascalStrings
)
555 Res
.push_back("-fpascal-strings");
556 if (Opts
.CatchUndefined
)
557 Res
.push_back("-fcatch-undefined-behavior");
558 if (Opts
.WritableStrings
)
559 Res
.push_back("-fwritable-strings");
560 if (Opts
.ConstStrings
)
561 Res
.push_back("-Wwrite-strings");
562 if (!Opts
.LaxVectorConversions
)
563 Res
.push_back("-fno-lax-vector-conversions");
565 Res
.push_back("-faltivec");
567 Res
.push_back("-fexceptions");
568 if (Opts
.SjLjExceptions
)
569 Res
.push_back("-fsjlj-exceptions");
571 Res
.push_back("-fno-rtti");
572 if (!Opts
.NeXTRuntime
)
573 Res
.push_back("-fgnu-runtime");
574 if (Opts
.Freestanding
)
575 Res
.push_back("-ffreestanding");
577 Res
.push_back("-fno-builtin");
578 if (!Opts
.AssumeSaneOperatorNew
)
579 Res
.push_back("-fno-assume-sane-operator-new");
580 if (!Opts
.ThreadsafeStatics
)
581 Res
.push_back("-fno-threadsafe-statics");
582 if (Opts
.POSIXThreads
)
583 Res
.push_back("-pthread");
585 Res
.push_back("-fblocks");
586 if (Opts
.EmitAllDecls
)
587 Res
.push_back("-femit-all-decls");
589 Res
.push_back("-fmath-errno");
590 switch (Opts
.getSignedOverflowBehavior()) {
591 case LangOptions::SOB_Undefined
: break;
592 case LangOptions::SOB_Defined
: Res
.push_back("-fwrapv"); break;
593 case LangOptions::SOB_Trapping
:
594 Res
.push_back("-ftrapv"); break;
595 if (!Opts
.OverflowHandler
.empty()) {
596 Res
.push_back("-ftrapv-handler");
597 Res
.push_back(Opts
.OverflowHandler
);
600 if (Opts
.HeinousExtensions
)
601 Res
.push_back("-fheinous-gnu-extensions");
602 // Optimize is implicit.
603 // OptimizeSize is implicit.
605 Res
.push_back("-static-define");
606 if (Opts
.DumpRecordLayouts
)
607 Res
.push_back("-fdump-record-layouts");
608 if (Opts
.DumpVTableLayouts
)
609 Res
.push_back("-fdump-vtable-layouts");
610 if (Opts
.NoBitFieldTypeAlign
)
611 Res
.push_back("-fno-bitfield-type-alignment");
612 if (Opts
.SjLjExceptions
)
613 Res
.push_back("-fsjlj-exceptions");
615 Res
.push_back("-pic-level");
616 Res
.push_back(llvm::utostr(Opts
.PICLevel
));
618 if (Opts
.ObjCGCBitmapPrint
)
619 Res
.push_back("-print-ivar-layout");
620 if (Opts
.NoConstantCFStrings
)
621 Res
.push_back("-fno-constant-cfstrings");
622 if (!Opts
.AccessControl
)
623 Res
.push_back("-fno-access-control");
624 if (!Opts
.CharIsSigned
)
625 Res
.push_back("-fno-signed-char");
627 Res
.push_back("-fshort-wchar");
628 if (!Opts
.ElideConstructors
)
629 Res
.push_back("-fno-elide-constructors");
630 if (Opts
.getGCMode() != LangOptions::NonGC
) {
631 if (Opts
.getGCMode() == LangOptions::HybridGC
) {
632 Res
.push_back("-fobjc-gc");
634 assert(Opts
.getGCMode() == LangOptions::GCOnly
&& "Invalid GC mode!");
635 Res
.push_back("-fobjc-gc-only");
638 if (Opts
.getVisibilityMode() != DefaultVisibility
) {
639 Res
.push_back("-fvisibility");
640 if (Opts
.getVisibilityMode() == HiddenVisibility
) {
641 Res
.push_back("hidden");
643 assert(Opts
.getVisibilityMode() == ProtectedVisibility
&&
644 "Invalid visibility!");
645 Res
.push_back("protected");
648 if (Opts
.InlineVisibilityHidden
)
649 Res
.push_back("-fvisibility-inlines-hidden");
651 if (Opts
.getStackProtectorMode() != 0) {
652 Res
.push_back("-stack-protector");
653 Res
.push_back(llvm::utostr(Opts
.getStackProtectorMode()));
655 if (Opts
.InstantiationDepth
!= DefaultLangOpts
.InstantiationDepth
) {
656 Res
.push_back("-ftemplate-depth");
657 Res
.push_back(llvm::utostr(Opts
.InstantiationDepth
));
659 if (!Opts
.ObjCConstantStringClass
.empty()) {
660 Res
.push_back("-fconstant-string-class");
661 Res
.push_back(Opts
.ObjCConstantStringClass
);
665 static void PreprocessorOptsToArgs(const PreprocessorOptions
&Opts
,
666 std::vector
<std::string
> &Res
) {
667 for (unsigned i
= 0, e
= Opts
.Macros
.size(); i
!= e
; ++i
)
668 Res
.push_back(std::string(Opts
.Macros
[i
].second
? "-U" : "-D") +
669 Opts
.Macros
[i
].first
);
670 for (unsigned i
= 0, e
= Opts
.Includes
.size(); i
!= e
; ++i
) {
671 // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
672 Res
.push_back("-include");
673 Res
.push_back(Opts
.Includes
[i
]);
675 for (unsigned i
= 0, e
= Opts
.MacroIncludes
.size(); i
!= e
; ++i
) {
676 Res
.push_back("-imacros");
677 Res
.push_back(Opts
.MacroIncludes
[i
]);
679 if (!Opts
.UsePredefines
)
680 Res
.push_back("-undef");
681 if (Opts
.DetailedRecord
)
682 Res
.push_back("-detailed-preprocessing-record");
683 if (!Opts
.ImplicitPCHInclude
.empty()) {
684 Res
.push_back("-include-pch");
685 Res
.push_back(Opts
.ImplicitPCHInclude
);
687 if (!Opts
.ImplicitPTHInclude
.empty()) {
688 Res
.push_back("-include-pth");
689 Res
.push_back(Opts
.ImplicitPTHInclude
);
691 if (!Opts
.TokenCache
.empty()) {
692 if (Opts
.ImplicitPTHInclude
.empty()) {
693 Res
.push_back("-token-cache");
694 Res
.push_back(Opts
.TokenCache
);
696 assert(Opts
.ImplicitPTHInclude
== Opts
.TokenCache
&&
697 "Unsupported option combination!");
699 for (unsigned i
= 0, e
= Opts
.RemappedFiles
.size(); i
!= e
; ++i
) {
700 Res
.push_back("-remap-file");
701 Res
.push_back(Opts
.RemappedFiles
[i
].first
+ ";" +
702 Opts
.RemappedFiles
[i
].second
);
706 static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions
&Opts
,
707 std::vector
<std::string
> &Res
) {
708 if (!Opts
.ShowCPP
&& !Opts
.ShowMacros
)
709 llvm::report_fatal_error("Invalid option combination!");
711 if (Opts
.ShowCPP
&& Opts
.ShowMacros
)
712 Res
.push_back("-dD");
713 else if (!Opts
.ShowCPP
&& Opts
.ShowMacros
)
714 Res
.push_back("-dM");
716 if (Opts
.ShowHeaderIncludes
)
718 if (!Opts
.ShowLineMarkers
)
720 if (Opts
.ShowComments
)
722 if (Opts
.ShowMacroComments
)
723 Res
.push_back("-CC");
726 static void TargetOptsToArgs(const TargetOptions
&Opts
,
727 std::vector
<std::string
> &Res
) {
728 Res
.push_back("-triple");
729 Res
.push_back(Opts
.Triple
);
730 if (!Opts
.CPU
.empty()) {
731 Res
.push_back("-target-cpu");
732 Res
.push_back(Opts
.CPU
);
734 if (!Opts
.ABI
.empty()) {
735 Res
.push_back("-target-abi");
736 Res
.push_back(Opts
.ABI
);
738 if (!Opts
.LinkerVersion
.empty()) {
739 Res
.push_back("-target-linker-version");
740 Res
.push_back(Opts
.LinkerVersion
);
742 if (!Opts
.CXXABI
.empty()) {
743 Res
.push_back("-cxx-abi");
744 Res
.push_back(Opts
.CXXABI
);
746 for (unsigned i
= 0, e
= Opts
.Features
.size(); i
!= e
; ++i
) {
747 Res
.push_back("-target-feature");
748 Res
.push_back(Opts
.Features
[i
]);
752 void CompilerInvocation::toArgs(std::vector
<std::string
> &Res
) {
753 AnalyzerOptsToArgs(getAnalyzerOpts(), Res
);
754 CodeGenOptsToArgs(getCodeGenOpts(), Res
);
755 DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res
);
756 DiagnosticOptsToArgs(getDiagnosticOpts(), Res
);
757 FileSystemOptsToArgs(getFileSystemOpts(), Res
);
758 FrontendOptsToArgs(getFrontendOpts(), Res
);
759 HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res
);
760 LangOptsToArgs(getLangOpts(), Res
);
761 PreprocessorOptsToArgs(getPreprocessorOpts(), Res
);
762 PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res
);
763 TargetOptsToArgs(getTargetOpts(), Res
);
766 //===----------------------------------------------------------------------===//
767 // Deserialization (to args)
768 //===----------------------------------------------------------------------===//
770 using namespace clang::driver
;
771 using namespace clang::driver::cc1options
;
775 static unsigned getOptimizationLevel(ArgList
&Args
, InputKind IK
,
777 unsigned DefaultOpt
= 0;
778 if (IK
== IK_OpenCL
&& !Args
.hasArg(OPT_cl_opt_disable
))
781 return Args
.hasArg(OPT_Os
) ? 2 :
782 Args
.getLastArgIntValue(OPT_O
, DefaultOpt
, Diags
);
785 static void ParseAnalyzerArgs(AnalyzerOptions
&Opts
, ArgList
&Args
,
787 using namespace cc1options
;
789 Opts
.AnalysisList
.clear();
790 #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) \
791 if (Args.hasArg(OPT_analysis_##NAME)) Opts.AnalysisList.push_back(NAME);
792 #include "clang/Frontend/Analyses.def"
794 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_store
)) {
795 llvm::StringRef Name
= A
->getValue(Args
);
796 AnalysisStores Value
= llvm::StringSwitch
<AnalysisStores
>(Name
)
797 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
798 .Case(CMDFLAG, NAME##Model)
799 #include "clang/Frontend/Analyses.def"
801 // FIXME: Error handling.
802 if (Value
== NumStores
)
803 Diags
.Report(diag::err_drv_invalid_value
)
804 << A
->getAsString(Args
) << Name
;
806 Opts
.AnalysisStoreOpt
= Value
;
809 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_constraints
)) {
810 llvm::StringRef Name
= A
->getValue(Args
);
811 AnalysisConstraints Value
= llvm::StringSwitch
<AnalysisConstraints
>(Name
)
812 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
813 .Case(CMDFLAG, NAME##Model)
814 #include "clang/Frontend/Analyses.def"
815 .Default(NumConstraints
);
816 // FIXME: Error handling.
817 if (Value
== NumConstraints
)
818 Diags
.Report(diag::err_drv_invalid_value
)
819 << A
->getAsString(Args
) << Name
;
821 Opts
.AnalysisConstraintsOpt
= Value
;
824 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_output
)) {
825 llvm::StringRef Name
= A
->getValue(Args
);
826 AnalysisDiagClients Value
= llvm::StringSwitch
<AnalysisDiagClients
>(Name
)
827 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
828 .Case(CMDFLAG, PD_##NAME)
829 #include "clang/Frontend/Analyses.def"
830 .Default(NUM_ANALYSIS_DIAG_CLIENTS
);
831 // FIXME: Error handling.
832 if (Value
== NUM_ANALYSIS_DIAG_CLIENTS
)
833 Diags
.Report(diag::err_drv_invalid_value
)
834 << A
->getAsString(Args
) << Name
;
836 Opts
.AnalysisDiagOpt
= Value
;
839 Opts
.VisualizeEGDot
= Args
.hasArg(OPT_analyzer_viz_egraph_graphviz
);
840 Opts
.VisualizeEGUbi
= Args
.hasArg(OPT_analyzer_viz_egraph_ubigraph
);
841 Opts
.AnalyzeAll
= Args
.hasArg(OPT_analyzer_opt_analyze_headers
);
842 Opts
.AnalyzerDisplayProgress
= Args
.hasArg(OPT_analyzer_display_progress
);
843 Opts
.AnalyzeNestedBlocks
=
844 Args
.hasArg(OPT_analyzer_opt_analyze_nested_blocks
);
845 Opts
.AnalyzerStats
= Args
.hasArg(OPT_analysis_AnalyzerStats
);
846 Opts
.PurgeDead
= !Args
.hasArg(OPT_analyzer_no_purge_dead
);
847 Opts
.EagerlyAssume
= Args
.hasArg(OPT_analyzer_eagerly_assume
);
848 Opts
.AnalyzeSpecificFunction
= Args
.getLastArgValue(OPT_analyze_function
);
849 Opts
.UnoptimizedCFG
= Args
.hasArg(OPT_analysis_UnoptimizedCFG
);
850 Opts
.CFGAddImplicitDtors
= Args
.hasArg(OPT_analysis_CFGAddImplicitDtors
);
851 Opts
.CFGAddInitializers
= Args
.hasArg(OPT_analysis_CFGAddInitializers
);
852 Opts
.EnableExperimentalChecks
= Args
.hasArg(OPT_analyzer_experimental_checks
);
853 Opts
.EnableExperimentalInternalChecks
=
854 Args
.hasArg(OPT_analyzer_experimental_internal_checks
);
855 Opts
.TrimGraph
= Args
.hasArg(OPT_trim_egraph
);
856 Opts
.MaxNodes
= Args
.getLastArgIntValue(OPT_analyzer_max_nodes
, 150000,Diags
);
857 Opts
.MaxLoop
= Args
.getLastArgIntValue(OPT_analyzer_max_loop
, 4, Diags
);
858 Opts
.InlineCall
= Args
.hasArg(OPT_analyzer_inline_call
);
859 Opts
.IdempotentOps
= Args
.hasArg(OPT_analysis_WarnIdempotentOps
);
862 static void ParseCodeGenArgs(CodeGenOptions
&Opts
, ArgList
&Args
, InputKind IK
,
864 using namespace cc1options
;
866 Opts
.OptimizationLevel
= getOptimizationLevel(Args
, IK
, Diags
);
867 if (Opts
.OptimizationLevel
> 3) {
868 Diags
.Report(diag::err_drv_invalid_value
)
869 << Args
.getLastArg(OPT_O
)->getAsString(Args
) << Opts
.OptimizationLevel
;
870 Opts
.OptimizationLevel
= 3;
873 // We must always run at least the always inlining pass.
874 Opts
.Inlining
= (Opts
.OptimizationLevel
> 1) ? CodeGenOptions::NormalInlining
875 : CodeGenOptions::OnlyAlwaysInlining
;
877 Opts
.DebugInfo
= Args
.hasArg(OPT_g
);
878 Opts
.LimitDebugInfo
= Args
.hasArg(OPT_flimit_debug_info
);
879 Opts
.DisableLLVMOpts
= Args
.hasArg(OPT_disable_llvm_optzns
);
880 Opts
.DisableRedZone
= Args
.hasArg(OPT_disable_red_zone
);
881 Opts
.RelaxedAliasing
= Args
.hasArg(OPT_relaxed_aliasing
);
882 Opts
.DwarfDebugFlags
= Args
.getLastArgValue(OPT_dwarf_debug_flags
);
883 Opts
.MergeAllConstants
= !Args
.hasArg(OPT_fno_merge_all_constants
);
884 Opts
.NoCommon
= Args
.hasArg(OPT_fno_common
);
885 Opts
.NoImplicitFloat
= Args
.hasArg(OPT_no_implicit_float
);
886 Opts
.OptimizeSize
= Args
.hasArg(OPT_Os
);
887 Opts
.SimplifyLibCalls
= !(Args
.hasArg(OPT_fno_builtin
) ||
888 Args
.hasArg(OPT_ffreestanding
));
889 Opts
.UnrollLoops
= Args
.hasArg(OPT_funroll_loops
) ||
890 (Opts
.OptimizationLevel
> 1 && !Opts
.OptimizeSize
);
892 Opts
.AsmVerbose
= Args
.hasArg(OPT_masm_verbose
);
893 Opts
.CXAAtExit
= !Args
.hasArg(OPT_fno_use_cxa_atexit
);
894 Opts
.CXXCtorDtorAliases
= Args
.hasArg(OPT_mconstructor_aliases
);
895 Opts
.CodeModel
= Args
.getLastArgValue(OPT_mcode_model
);
896 Opts
.DebugPass
= Args
.getLastArgValue(OPT_mdebug_pass
);
897 Opts
.DisableFPElim
= Args
.hasArg(OPT_mdisable_fp_elim
);
898 Opts
.FloatABI
= Args
.getLastArgValue(OPT_mfloat_abi
);
899 Opts
.HiddenWeakVTables
= Args
.hasArg(OPT_fhidden_weak_vtables
);
900 Opts
.LessPreciseFPMAD
= Args
.hasArg(OPT_cl_mad_enable
);
901 Opts
.LimitFloatPrecision
= Args
.getLastArgValue(OPT_mlimit_float_precision
);
902 Opts
.NoInfsFPMath
= Opts
.NoNaNsFPMath
= Args
.hasArg(OPT_cl_finite_math_only
)||
903 Args
.hasArg(OPT_cl_fast_relaxed_math
);
904 Opts
.NoZeroInitializedInBSS
= Args
.hasArg(OPT_mno_zero_initialized_in_bss
);
905 Opts
.RelaxAll
= Args
.hasArg(OPT_mrelax_all
);
906 Opts
.OmitLeafFramePointer
= Args
.hasArg(OPT_momit_leaf_frame_pointer
);
907 Opts
.SoftFloat
= Args
.hasArg(OPT_msoft_float
);
908 Opts
.UnsafeFPMath
= Args
.hasArg(OPT_cl_unsafe_math_optimizations
) ||
909 Args
.hasArg(OPT_cl_fast_relaxed_math
);
910 Opts
.UnwindTables
= Args
.hasArg(OPT_munwind_tables
);
911 Opts
.RelocationModel
= Args
.getLastArgValue(OPT_mrelocation_model
, "pic");
913 Opts
.FunctionSections
= Args
.hasArg(OPT_ffunction_sections
);
914 Opts
.DataSections
= Args
.hasArg(OPT_fdata_sections
);
916 Opts
.MainFileName
= Args
.getLastArgValue(OPT_main_file_name
);
917 Opts
.VerifyModule
= !Args
.hasArg(OPT_disable_llvm_verifier
);
919 Opts
.InstrumentFunctions
= Args
.hasArg(OPT_finstrument_functions
);
921 if (Arg
*A
= Args
.getLastArg(OPT_fobjc_dispatch_method_EQ
)) {
922 llvm::StringRef Name
= A
->getValue(Args
);
923 unsigned Method
= llvm::StringSwitch
<unsigned>(Name
)
924 .Case("legacy", CodeGenOptions::Legacy
)
925 .Case("non-legacy", CodeGenOptions::NonLegacy
)
926 .Case("mixed", CodeGenOptions::Mixed
)
929 Diags
.Report(diag::err_drv_invalid_value
) << A
->getAsString(Args
) << Name
;
931 Opts
.ObjCDispatchMethod
= Method
;
935 static void ParseDependencyOutputArgs(DependencyOutputOptions
&Opts
,
937 using namespace cc1options
;
938 Opts
.OutputFile
= Args
.getLastArgValue(OPT_dependency_file
);
939 Opts
.Targets
= Args
.getAllArgValues(OPT_MT
);
940 Opts
.IncludeSystemHeaders
= Args
.hasArg(OPT_sys_header_deps
);
941 Opts
.UsePhonyTargets
= Args
.hasArg(OPT_MP
);
944 static void ParseDiagnosticArgs(DiagnosticOptions
&Opts
, ArgList
&Args
,
946 using namespace cc1options
;
947 Opts
.IgnoreWarnings
= Args
.hasArg(OPT_w
);
948 Opts
.NoRewriteMacros
= Args
.hasArg(OPT_Wno_rewrite_macros
);
949 Opts
.Pedantic
= Args
.hasArg(OPT_pedantic
);
950 Opts
.PedanticErrors
= Args
.hasArg(OPT_pedantic_errors
);
951 Opts
.ShowCarets
= !Args
.hasArg(OPT_fno_caret_diagnostics
);
952 Opts
.ShowColors
= Args
.hasArg(OPT_fcolor_diagnostics
);
953 Opts
.ShowColumn
= !Args
.hasArg(OPT_fno_show_column
);
954 Opts
.ShowFixits
= !Args
.hasArg(OPT_fno_diagnostics_fixit_info
);
955 Opts
.ShowLocation
= !Args
.hasArg(OPT_fno_show_source_location
);
956 Opts
.ShowOptionNames
= Args
.hasArg(OPT_fdiagnostics_show_option
);
958 llvm::StringRef ShowOverloads
=
959 Args
.getLastArgValue(OPT_fshow_overloads_EQ
, "all");
960 if (ShowOverloads
== "best")
961 Opts
.ShowOverloads
= Diagnostic::Ovl_Best
;
962 else if (ShowOverloads
== "all")
963 Opts
.ShowOverloads
= Diagnostic::Ovl_All
;
965 Diags
.Report(diag::err_drv_invalid_value
)
966 << Args
.getLastArg(OPT_fshow_overloads_EQ
)->getAsString(Args
)
969 llvm::StringRef ShowCategory
=
970 Args
.getLastArgValue(OPT_fdiagnostics_show_category
, "none");
971 if (ShowCategory
== "none")
972 Opts
.ShowCategories
= 0;
973 else if (ShowCategory
== "id")
974 Opts
.ShowCategories
= 1;
975 else if (ShowCategory
== "name")
976 Opts
.ShowCategories
= 2;
978 Diags
.Report(diag::err_drv_invalid_value
)
979 << Args
.getLastArg(OPT_fdiagnostics_show_category
)->getAsString(Args
)
982 Opts
.ShowSourceRanges
= Args
.hasArg(OPT_fdiagnostics_print_source_range_info
);
983 Opts
.ShowParseableFixits
= Args
.hasArg(OPT_fdiagnostics_parseable_fixits
);
984 Opts
.VerifyDiagnostics
= Args
.hasArg(OPT_verify
);
985 Opts
.ErrorLimit
= Args
.getLastArgIntValue(OPT_ferror_limit
, 0, Diags
);
986 Opts
.MacroBacktraceLimit
987 = Args
.getLastArgIntValue(OPT_fmacro_backtrace_limit
,
988 DiagnosticOptions::DefaultMacroBacktraceLimit
, Diags
);
989 Opts
.TemplateBacktraceLimit
990 = Args
.getLastArgIntValue(OPT_ftemplate_backtrace_limit
,
991 DiagnosticOptions::DefaultTemplateBacktraceLimit
,
993 Opts
.TabStop
= Args
.getLastArgIntValue(OPT_ftabstop
,
994 DiagnosticOptions::DefaultTabStop
, Diags
);
995 if (Opts
.TabStop
== 0 || Opts
.TabStop
> DiagnosticOptions::MaxTabStop
) {
996 Diags
.Report(diag::warn_ignoring_ftabstop_value
)
997 << Opts
.TabStop
<< DiagnosticOptions::DefaultTabStop
;
998 Opts
.TabStop
= DiagnosticOptions::DefaultTabStop
;
1000 Opts
.MessageLength
= Args
.getLastArgIntValue(OPT_fmessage_length
, 0, Diags
);
1001 Opts
.DumpBuildInformation
= Args
.getLastArgValue(OPT_dump_build_information
);
1002 Opts
.Warnings
= Args
.getAllArgValues(OPT_W
);
1005 static void ParseFileSystemArgs(FileSystemOptions
&Opts
, ArgList
&Args
) {
1006 Opts
.WorkingDir
= Args
.getLastArgValue(OPT_working_directory
);
1009 static InputKind
ParseFrontendArgs(FrontendOptions
&Opts
, ArgList
&Args
,
1010 Diagnostic
&Diags
) {
1011 using namespace cc1options
;
1012 Opts
.ProgramAction
= frontend::ParseSyntaxOnly
;
1013 if (const Arg
*A
= Args
.getLastArg(OPT_Action_Group
)) {
1014 switch (A
->getOption().getID()) {
1016 assert(0 && "Invalid option in group!");
1018 Opts
.ProgramAction
= frontend::ASTDump
; break;
1019 case OPT_ast_dump_xml
:
1020 Opts
.ProgramAction
= frontend::ASTDumpXML
; break;
1022 Opts
.ProgramAction
= frontend::ASTPrint
; break;
1023 case OPT_ast_print_xml
:
1024 Opts
.ProgramAction
= frontend::ASTPrintXML
; break;
1026 Opts
.ProgramAction
= frontend::ASTView
; break;
1028 Opts
.ProgramAction
= frontend::BoostCon
; break;
1029 case OPT_dump_raw_tokens
:
1030 Opts
.ProgramAction
= frontend::DumpRawTokens
; break;
1031 case OPT_dump_tokens
:
1032 Opts
.ProgramAction
= frontend::DumpTokens
; break;
1034 Opts
.ProgramAction
= frontend::EmitAssembly
; break;
1035 case OPT_emit_llvm_bc
:
1036 Opts
.ProgramAction
= frontend::EmitBC
; break;
1038 Opts
.ProgramAction
= frontend::EmitHTML
; break;
1040 Opts
.ProgramAction
= frontend::EmitLLVM
; break;
1041 case OPT_emit_llvm_only
:
1042 Opts
.ProgramAction
= frontend::EmitLLVMOnly
; break;
1043 case OPT_emit_codegen_only
:
1044 Opts
.ProgramAction
= frontend::EmitCodeGenOnly
; break;
1046 Opts
.ProgramAction
= frontend::EmitObj
; break;
1048 Opts
.FixItSuffix
= A
->getValue(Args
);
1051 Opts
.ProgramAction
= frontend::FixIt
; break;
1053 Opts
.ProgramAction
= frontend::GeneratePCH
; break;
1055 Opts
.ProgramAction
= frontend::GeneratePTH
; break;
1057 Opts
.ProgramAction
= frontend::InitOnly
; break;
1058 case OPT_fsyntax_only
:
1059 Opts
.ProgramAction
= frontend::ParseSyntaxOnly
; break;
1060 case OPT_print_decl_contexts
:
1061 Opts
.ProgramAction
= frontend::PrintDeclContext
; break;
1062 case OPT_print_preamble
:
1063 Opts
.ProgramAction
= frontend::PrintPreamble
; break;
1065 Opts
.ProgramAction
= frontend::PrintPreprocessedInput
; break;
1066 case OPT_rewrite_macros
:
1067 Opts
.ProgramAction
= frontend::RewriteMacros
; break;
1068 case OPT_rewrite_objc
:
1069 Opts
.ProgramAction
= frontend::RewriteObjC
; break;
1070 case OPT_rewrite_test
:
1071 Opts
.ProgramAction
= frontend::RewriteTest
; break;
1073 Opts
.ProgramAction
= frontend::RunAnalysis
; break;
1075 Opts
.ProgramAction
= frontend::RunPreprocessorOnly
; break;
1076 case OPT_create_module
:
1077 Opts
.ProgramAction
= frontend::CreateModule
; break;
1081 if (const Arg
* A
= Args
.getLastArg(OPT_plugin
)) {
1082 Opts
.Plugins
.push_back(A
->getValue(Args
,0));
1083 Opts
.ProgramAction
= frontend::PluginAction
;
1084 Opts
.ActionName
= A
->getValue(Args
);
1086 for (arg_iterator it
= Args
.filtered_begin(OPT_plugin_arg
),
1087 end
= Args
.filtered_end(); it
!= end
; ++it
) {
1088 if ((*it
)->getValue(Args
, 0) == Opts
.ActionName
)
1089 Opts
.PluginArgs
.push_back((*it
)->getValue(Args
, 1));
1093 if (const Arg
*A
= Args
.getLastArg(OPT_code_completion_at
)) {
1094 Opts
.CodeCompletionAt
=
1095 ParsedSourceLocation::FromString(A
->getValue(Args
));
1096 if (Opts
.CodeCompletionAt
.FileName
.empty())
1097 Diags
.Report(diag::err_drv_invalid_value
)
1098 << A
->getAsString(Args
) << A
->getValue(Args
);
1100 Opts
.DisableFree
= Args
.hasArg(OPT_disable_free
);
1102 Opts
.OutputFile
= Args
.getLastArgValue(OPT_o
);
1103 Opts
.Plugins
= Args
.getAllArgValues(OPT_load
);
1104 Opts
.RelocatablePCH
= Args
.hasArg(OPT_relocatable_pch
);
1105 Opts
.ChainedPCH
= Args
.hasArg(OPT_chained_pch
);
1106 Opts
.ShowHelp
= Args
.hasArg(OPT_help
);
1107 Opts
.ShowMacrosInCodeCompletion
= Args
.hasArg(OPT_code_completion_macros
);
1108 Opts
.ShowCodePatternsInCodeCompletion
1109 = Args
.hasArg(OPT_code_completion_patterns
);
1110 Opts
.ShowGlobalSymbolsInCodeCompletion
1111 = !Args
.hasArg(OPT_no_code_completion_globals
);
1112 Opts
.ShowStats
= Args
.hasArg(OPT_print_stats
);
1113 Opts
.ShowTimers
= Args
.hasArg(OPT_ftime_report
);
1114 Opts
.ShowVersion
= Args
.hasArg(OPT_version
);
1115 Opts
.ViewClassInheritance
= Args
.getLastArgValue(OPT_cxx_inheritance_view
);
1116 Opts
.ASTMergeFiles
= Args
.getAllArgValues(OPT_ast_merge
);
1117 Opts
.LLVMArgs
= Args
.getAllArgValues(OPT_mllvm
);
1118 Opts
.FixWhatYouCan
= Args
.hasArg(OPT_fix_what_you_can
);
1119 Opts
.Modules
= Args
.getAllArgValues(OPT_import_module
);
1121 InputKind DashX
= IK_None
;
1122 if (const Arg
*A
= Args
.getLastArg(OPT_x
)) {
1123 DashX
= llvm::StringSwitch
<InputKind
>(A
->getValue(Args
))
1125 .Case("cl", IK_OpenCL
)
1127 .Case("cl", IK_OpenCL
)
1128 .Case("cuda", IK_CUDA
)
1129 .Case("c++", IK_CXX
)
1130 .Case("objective-c", IK_ObjC
)
1131 .Case("objective-c++", IK_ObjCXX
)
1132 .Case("cpp-output", IK_PreprocessedC
)
1133 .Case("assembler-with-cpp", IK_Asm
)
1134 .Case("c++-cpp-output", IK_PreprocessedCXX
)
1135 .Case("objective-c-cpp-output", IK_PreprocessedObjC
)
1136 .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX
)
1137 .Case("c-header", IK_C
)
1138 .Case("objective-c-header", IK_ObjC
)
1139 .Case("c++-header", IK_CXX
)
1140 .Case("objective-c++-header", IK_ObjCXX
)
1141 .Case("ast", IK_AST
)
1142 .Case("ir", IK_LLVM_IR
)
1144 if (DashX
== IK_None
)
1145 Diags
.Report(diag::err_drv_invalid_value
)
1146 << A
->getAsString(Args
) << A
->getValue(Args
);
1149 // '-' is the default input if none is given.
1150 std::vector
<std::string
> Inputs
= Args
.getAllArgValues(OPT_INPUT
);
1151 Opts
.Inputs
.clear();
1153 Inputs
.push_back("-");
1154 for (unsigned i
= 0, e
= Inputs
.size(); i
!= e
; ++i
) {
1155 InputKind IK
= DashX
;
1156 if (IK
== IK_None
) {
1157 IK
= FrontendOptions::getInputKindForExtension(
1158 llvm::StringRef(Inputs
[i
]).rsplit('.').second
);
1159 // FIXME: Remove this hack.
1163 Opts
.Inputs
.push_back(std::make_pair(IK
, Inputs
[i
]));
1169 std::string
CompilerInvocation::GetResourcesPath(const char *Argv0
,
1171 llvm::sys::Path P
= llvm::sys::Path::GetMainExecutable(Argv0
, MainAddr
);
1174 P
.eraseComponent(); // Remove /clang from foo/bin/clang
1175 P
.eraseComponent(); // Remove /bin from foo/bin
1177 // Get foo/lib/clang/<version>/include
1178 P
.appendComponent("lib");
1179 P
.appendComponent("clang");
1180 P
.appendComponent(CLANG_VERSION_STRING
);
1186 static void ParseHeaderSearchArgs(HeaderSearchOptions
&Opts
, ArgList
&Args
) {
1187 using namespace cc1options
;
1188 Opts
.CXXSystemIncludes
= Args
.getAllArgValues(OPT_cxx_system_include
);
1189 Opts
.Sysroot
= Args
.getLastArgValue(OPT_isysroot
, "/");
1190 Opts
.Verbose
= Args
.hasArg(OPT_v
);
1191 Opts
.UseBuiltinIncludes
= !Args
.hasArg(OPT_nobuiltininc
);
1192 Opts
.UseStandardIncludes
= !Args
.hasArg(OPT_nostdinc
);
1193 Opts
.UseStandardCXXIncludes
= !Args
.hasArg(OPT_nostdincxx
);
1194 Opts
.ResourceDir
= Args
.getLastArgValue(OPT_resource_dir
);
1196 // Add -I... and -F... options in order.
1197 for (arg_iterator it
= Args
.filtered_begin(OPT_I
, OPT_F
),
1198 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1199 Opts
.AddPath((*it
)->getValue(Args
), frontend::Angled
, true,
1200 /*IsFramework=*/ (*it
)->getOption().matches(OPT_F
), true);
1202 // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1203 llvm::StringRef Prefix
= ""; // FIXME: This isn't the correct default prefix.
1204 for (arg_iterator it
= Args
.filtered_begin(OPT_iprefix
, OPT_iwithprefix
,
1205 OPT_iwithprefixbefore
),
1206 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1208 if (A
->getOption().matches(OPT_iprefix
))
1209 Prefix
= A
->getValue(Args
);
1210 else if (A
->getOption().matches(OPT_iwithprefix
))
1211 Opts
.AddPath(Prefix
.str() + A
->getValue(Args
),
1212 frontend::System
, false, false, true);
1214 Opts
.AddPath(Prefix
.str() + A
->getValue(Args
),
1215 frontend::Angled
, false, false, true);
1218 for (arg_iterator it
= Args
.filtered_begin(OPT_idirafter
),
1219 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1220 Opts
.AddPath((*it
)->getValue(Args
), frontend::After
, true, false, true);
1221 for (arg_iterator it
= Args
.filtered_begin(OPT_iquote
),
1222 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1223 Opts
.AddPath((*it
)->getValue(Args
), frontend::Quoted
, true, false, true);
1224 for (arg_iterator it
= Args
.filtered_begin(OPT_isystem
, OPT_iwithsysroot
),
1225 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1226 Opts
.AddPath((*it
)->getValue(Args
), frontend::System
, true, false,
1227 (*it
)->getOption().matches(OPT_iwithsysroot
));
1229 // FIXME: Need options for the various environment variables!
1232 void CompilerInvocation::setLangDefaults(LangOptions
&Opts
, InputKind IK
,
1233 LangStandard::Kind LangStd
) {
1234 // Set some properties which depend soley on the input kind; it would be nice
1235 // to move these to the language standard, and have the driver resolve the
1236 // input kind + language standard.
1238 Opts
.AsmPreprocessor
= 1;
1239 } else if (IK
== IK_ObjC
||
1241 IK
== IK_PreprocessedObjC
||
1242 IK
== IK_PreprocessedObjCXX
) {
1243 Opts
.ObjC1
= Opts
.ObjC2
= 1;
1246 if (LangStd
== LangStandard::lang_unspecified
) {
1247 // Based on the base language, pick one.
1252 assert(0 && "Invalid input kind!");
1254 LangStd
= LangStandard::lang_opencl
;
1257 LangStd
= LangStandard::lang_cuda
;
1261 case IK_PreprocessedC
:
1263 case IK_PreprocessedObjC
:
1264 LangStd
= LangStandard::lang_gnu99
;
1267 case IK_PreprocessedCXX
:
1269 case IK_PreprocessedObjCXX
:
1270 LangStd
= LangStandard::lang_gnucxx98
;
1275 const LangStandard
&Std
= LangStandard::getLangStandardForKind(LangStd
);
1276 Opts
.BCPLComment
= Std
.hasBCPLComments();
1277 Opts
.C99
= Std
.isC99();
1278 Opts
.CPlusPlus
= Std
.isCPlusPlus();
1279 Opts
.CPlusPlus0x
= Std
.isCPlusPlus0x();
1280 Opts
.Digraphs
= Std
.hasDigraphs();
1281 Opts
.GNUMode
= Std
.isGNUMode();
1282 Opts
.GNUInline
= !Std
.isC99();
1283 Opts
.HexFloats
= Std
.hasHexFloats();
1284 Opts
.ImplicitInt
= Std
.hasImplicitInt();
1286 // OpenCL has some additional defaults.
1287 if (LangStd
== LangStandard::lang_opencl
) {
1290 Opts
.CXXOperatorNames
= 1;
1291 Opts
.LaxVectorConversions
= 1;
1294 if (LangStd
== LangStandard::lang_cuda
)
1297 // OpenCL and C++ both have bool, true, false keywords.
1298 Opts
.Bool
= Opts
.OpenCL
|| Opts
.CPlusPlus
;
1300 Opts
.GNUKeywords
= Opts
.GNUMode
;
1301 Opts
.CXXOperatorNames
= Opts
.CPlusPlus
;
1303 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1304 // is specified, or -std is set to a conforming mode.
1305 Opts
.Trigraphs
= !Opts
.GNUMode
;
1307 Opts
.DollarIdents
= !Opts
.AsmPreprocessor
;
1310 static void ParseLangArgs(LangOptions
&Opts
, ArgList
&Args
, InputKind IK
,
1311 Diagnostic
&Diags
) {
1312 // FIXME: Cleanup per-file based stuff.
1313 LangStandard::Kind LangStd
= LangStandard::lang_unspecified
;
1314 if (const Arg
*A
= Args
.getLastArg(OPT_std_EQ
)) {
1315 LangStd
= llvm::StringSwitch
<LangStandard::Kind
>(A
->getValue(Args
))
1316 #define LANGSTANDARD(id, name, desc, features) \
1317 .Case(name, LangStandard::lang_##id)
1318 #include "clang/Frontend/LangStandards.def"
1319 .Default(LangStandard::lang_unspecified
);
1320 if (LangStd
== LangStandard::lang_unspecified
)
1321 Diags
.Report(diag::err_drv_invalid_value
)
1322 << A
->getAsString(Args
) << A
->getValue(Args
);
1325 if (const Arg
*A
= Args
.getLastArg(OPT_cl_std_EQ
)) {
1326 if (strcmp(A
->getValue(Args
), "CL1.1") != 0) {
1327 Diags
.Report(diag::err_drv_invalid_value
)
1328 << A
->getAsString(Args
) << A
->getValue(Args
);
1332 CompilerInvocation::setLangDefaults(Opts
, IK
, LangStd
);
1334 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1335 // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1336 // while a subset (the non-C++ GNU keywords) is provided by GCC's
1337 // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1338 // name, as it doesn't seem a useful distinction.
1339 Opts
.GNUKeywords
= Args
.hasFlag(OPT_fgnu_keywords
, OPT_fno_gnu_keywords
,
1342 if (Args
.hasArg(OPT_fno_operator_names
))
1343 Opts
.CXXOperatorNames
= 0;
1345 if (Args
.hasArg(OPT_fobjc_gc_only
))
1346 Opts
.setGCMode(LangOptions::GCOnly
);
1347 else if (Args
.hasArg(OPT_fobjc_gc
))
1348 Opts
.setGCMode(LangOptions::HybridGC
);
1350 if (Args
.hasArg(OPT_print_ivar_layout
))
1351 Opts
.ObjCGCBitmapPrint
= 1;
1352 if (Args
.hasArg(OPT_fno_constant_cfstrings
))
1353 Opts
.NoConstantCFStrings
= 1;
1355 if (Args
.hasArg(OPT_faltivec
))
1358 if (Args
.hasArg(OPT_pthread
))
1359 Opts
.POSIXThreads
= 1;
1361 llvm::StringRef Vis
= Args
.getLastArgValue(OPT_fvisibility
, "default");
1362 if (Vis
== "default")
1363 Opts
.setVisibilityMode(DefaultVisibility
);
1364 else if (Vis
== "hidden")
1365 Opts
.setVisibilityMode(HiddenVisibility
);
1366 else if (Vis
== "protected")
1367 Opts
.setVisibilityMode(ProtectedVisibility
);
1369 Diags
.Report(diag::err_drv_invalid_value
)
1370 << Args
.getLastArg(OPT_fvisibility
)->getAsString(Args
) << Vis
;
1372 if (Args
.hasArg(OPT_fvisibility_inlines_hidden
))
1373 Opts
.InlineVisibilityHidden
= 1;
1375 if (Args
.hasArg(OPT_ftrapv
)) {
1376 Opts
.setSignedOverflowBehavior(LangOptions::SOB_Trapping
);
1377 // Set the handler, if one is specified.
1378 Opts
.OverflowHandler
=
1379 Args
.getLastArgValue(OPT_ftrapv_handler
);
1381 else if (Args
.hasArg(OPT_fwrapv
))
1382 Opts
.setSignedOverflowBehavior(LangOptions::SOB_Defined
);
1384 if (Args
.hasArg(OPT_trigraphs
))
1387 Opts
.DollarIdents
= Args
.hasFlag(OPT_fdollars_in_identifiers
,
1388 OPT_fno_dollars_in_identifiers
,
1390 Opts
.PascalStrings
= Args
.hasArg(OPT_fpascal_strings
);
1391 Opts
.Microsoft
= Args
.hasArg(OPT_fms_extensions
);
1392 Opts
.MSCVersion
= Args
.getLastArgIntValue(OPT_fmsc_version
, 0, Diags
);
1393 Opts
.Borland
= Args
.hasArg(OPT_fborland_extensions
);
1394 Opts
.WritableStrings
= Args
.hasArg(OPT_fwritable_strings
);
1395 Opts
.ConstStrings
= Args
.hasArg(OPT_Wwrite_strings
);
1396 if (Args
.hasArg(OPT_fno_lax_vector_conversions
))
1397 Opts
.LaxVectorConversions
= 0;
1398 if (Args
.hasArg(OPT_fno_threadsafe_statics
))
1399 Opts
.ThreadsafeStatics
= 0;
1400 Opts
.Exceptions
= Args
.hasArg(OPT_fexceptions
);
1401 Opts
.RTTI
= !Args
.hasArg(OPT_fno_rtti
);
1402 Opts
.Blocks
= Args
.hasArg(OPT_fblocks
);
1403 Opts
.CharIsSigned
= !Args
.hasArg(OPT_fno_signed_char
);
1404 Opts
.ShortWChar
= Args
.hasArg(OPT_fshort_wchar
);
1405 Opts
.ShortEnums
= Args
.hasArg(OPT_fshort_enums
);
1406 Opts
.Freestanding
= Args
.hasArg(OPT_ffreestanding
);
1407 Opts
.NoBuiltin
= Args
.hasArg(OPT_fno_builtin
) || Opts
.Freestanding
;
1408 Opts
.AssumeSaneOperatorNew
= !Args
.hasArg(OPT_fno_assume_sane_operator_new
);
1409 Opts
.HeinousExtensions
= Args
.hasArg(OPT_fheinous_gnu_extensions
);
1410 Opts
.AccessControl
= !Args
.hasArg(OPT_fno_access_control
);
1411 Opts
.ElideConstructors
= !Args
.hasArg(OPT_fno_elide_constructors
);
1412 Opts
.MathErrno
= Args
.hasArg(OPT_fmath_errno
);
1413 Opts
.InstantiationDepth
= Args
.getLastArgIntValue(OPT_ftemplate_depth
, 1024,
1415 Opts
.NumLargeByValueCopy
= Args
.getLastArgIntValue(OPT_Wlarge_by_value_copy
,
1417 Opts
.NeXTRuntime
= !Args
.hasArg(OPT_fgnu_runtime
);
1418 Opts
.ObjCConstantStringClass
=
1419 Args
.getLastArgValue(OPT_fconstant_string_class
);
1420 Opts
.ObjCNonFragileABI
= Args
.hasArg(OPT_fobjc_nonfragile_abi
);
1421 Opts
.ObjCNonFragileABI2
= Args
.hasArg(OPT_fobjc_nonfragile_abi2
);
1422 if (Opts
.ObjCNonFragileABI2
)
1423 Opts
.ObjCNonFragileABI
= true;
1424 Opts
.CatchUndefined
= Args
.hasArg(OPT_fcatch_undefined_behavior
);
1425 Opts
.EmitAllDecls
= Args
.hasArg(OPT_femit_all_decls
);
1426 Opts
.PICLevel
= Args
.getLastArgIntValue(OPT_pic_level
, 0, Diags
);
1427 Opts
.SjLjExceptions
= Args
.hasArg(OPT_fsjlj_exceptions
);
1428 Opts
.Static
= Args
.hasArg(OPT_static_define
);
1429 Opts
.DumpRecordLayouts
= Args
.hasArg(OPT_fdump_record_layouts
);
1430 Opts
.DumpVTableLayouts
= Args
.hasArg(OPT_fdump_vtable_layouts
);
1431 Opts
.SpellChecking
= !Args
.hasArg(OPT_fno_spell_checking
);
1432 Opts
.NoBitFieldTypeAlign
= Args
.hasArg(OPT_fno_bitfield_type_align
);
1433 Opts
.SinglePrecisionConstants
= Args
.hasArg(OPT_cl_single_precision_constant
);
1434 Opts
.FastRelaxedMath
= Args
.hasArg(OPT_cl_fast_relaxed_math
);
1435 Opts
.OptimizeSize
= 0;
1437 // FIXME: Eliminate this dependency.
1438 unsigned Opt
= getOptimizationLevel(Args
, IK
, Diags
);
1439 Opts
.Optimize
= Opt
!= 0;
1441 // This is the __NO_INLINE__ define, which just depends on things like the
1442 // optimization level and -fno-inline, not actually whether the backend has
1443 // inlining enabled.
1445 // FIXME: This is affected by other options (-fno-inline).
1446 Opts
.NoInline
= !Opt
;
1448 unsigned SSP
= Args
.getLastArgIntValue(OPT_stack_protector
, 0, Diags
);
1451 Diags
.Report(diag::err_drv_invalid_value
)
1452 << Args
.getLastArg(OPT_stack_protector
)->getAsString(Args
) << SSP
;
1454 case 0: Opts
.setStackProtectorMode(LangOptions::SSPOff
); break;
1455 case 1: Opts
.setStackProtectorMode(LangOptions::SSPOn
); break;
1456 case 2: Opts
.setStackProtectorMode(LangOptions::SSPReq
); break;
1460 static void ParsePreprocessorArgs(PreprocessorOptions
&Opts
, ArgList
&Args
,
1461 FileManager
&FileMgr
,
1462 Diagnostic
&Diags
) {
1463 using namespace cc1options
;
1464 Opts
.ImplicitPCHInclude
= Args
.getLastArgValue(OPT_include_pch
);
1465 Opts
.ImplicitPTHInclude
= Args
.getLastArgValue(OPT_include_pth
);
1466 if (const Arg
*A
= Args
.getLastArg(OPT_token_cache
))
1467 Opts
.TokenCache
= A
->getValue(Args
);
1469 Opts
.TokenCache
= Opts
.ImplicitPTHInclude
;
1470 Opts
.UsePredefines
= !Args
.hasArg(OPT_undef
);
1471 Opts
.DetailedRecord
= Args
.hasArg(OPT_detailed_preprocessing_record
);
1472 Opts
.DisablePCHValidation
= Args
.hasArg(OPT_fno_validate_pch
);
1474 Opts
.DumpDeserializedPCHDecls
= Args
.hasArg(OPT_dump_deserialized_pch_decls
);
1475 for (arg_iterator it
= Args
.filtered_begin(OPT_error_on_deserialized_pch_decl
),
1476 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1478 Opts
.DeserializedPCHDeclsToErrorOn
.insert(A
->getValue(Args
));
1481 if (const Arg
*A
= Args
.getLastArg(OPT_preamble_bytes_EQ
)) {
1482 llvm::StringRef
Value(A
->getValue(Args
));
1483 size_t Comma
= Value
.find(',');
1485 unsigned EndOfLine
= 0;
1487 if (Comma
== llvm::StringRef::npos
||
1488 Value
.substr(0, Comma
).getAsInteger(10, Bytes
) ||
1489 Value
.substr(Comma
+ 1).getAsInteger(10, EndOfLine
))
1490 Diags
.Report(diag::err_drv_preamble_format
);
1492 Opts
.PrecompiledPreambleBytes
.first
= Bytes
;
1493 Opts
.PrecompiledPreambleBytes
.second
= (EndOfLine
!= 0);
1497 // Add macros from the command line.
1498 for (arg_iterator it
= Args
.filtered_begin(OPT_D
, OPT_U
),
1499 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1500 if ((*it
)->getOption().matches(OPT_D
))
1501 Opts
.addMacroDef((*it
)->getValue(Args
));
1503 Opts
.addMacroUndef((*it
)->getValue(Args
));
1506 Opts
.MacroIncludes
= Args
.getAllArgValues(OPT_imacros
);
1508 // Add the ordered list of -includes.
1509 for (arg_iterator it
= Args
.filtered_begin(OPT_include
, OPT_include_pch
,
1511 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1513 // PCH is handled specially, we need to extra the original include path.
1514 if (A
->getOption().matches(OPT_include_pch
)) {
1515 std::string OriginalFile
=
1516 ASTReader::getOriginalSourceFile(A
->getValue(Args
), FileMgr
, Diags
);
1517 if (OriginalFile
.empty())
1520 Opts
.Includes
.push_back(OriginalFile
);
1522 Opts
.Includes
.push_back(A
->getValue(Args
));
1525 // Include 'altivec.h' if -faltivec option present
1526 if (Args
.hasArg(OPT_faltivec
))
1527 Opts
.Includes
.push_back("altivec.h");
1529 for (arg_iterator it
= Args
.filtered_begin(OPT_remap_file
),
1530 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1532 std::pair
<llvm::StringRef
,llvm::StringRef
> Split
=
1533 llvm::StringRef(A
->getValue(Args
)).split(';');
1535 if (Split
.second
.empty()) {
1536 Diags
.Report(diag::err_drv_invalid_remap_file
) << A
->getAsString(Args
);
1540 Opts
.addRemappedFile(Split
.first
, Split
.second
);
1544 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions
&Opts
,
1546 using namespace cc1options
;
1547 Opts
.ShowCPP
= !Args
.hasArg(OPT_dM
);
1548 Opts
.ShowComments
= Args
.hasArg(OPT_C
);
1549 Opts
.ShowHeaderIncludes
= Args
.hasArg(OPT_H
);
1550 Opts
.ShowLineMarkers
= !Args
.hasArg(OPT_P
);
1551 Opts
.ShowMacroComments
= Args
.hasArg(OPT_CC
);
1552 Opts
.ShowMacros
= Args
.hasArg(OPT_dM
) || Args
.hasArg(OPT_dD
);
1555 static void ParseTargetArgs(TargetOptions
&Opts
, ArgList
&Args
) {
1556 using namespace cc1options
;
1557 Opts
.ABI
= Args
.getLastArgValue(OPT_target_abi
);
1558 Opts
.CXXABI
= Args
.getLastArgValue(OPT_cxx_abi
);
1559 Opts
.CPU
= Args
.getLastArgValue(OPT_target_cpu
);
1560 Opts
.Features
= Args
.getAllArgValues(OPT_target_feature
);
1561 Opts
.LinkerVersion
= Args
.getLastArgValue(OPT_target_linker_version
);
1562 Opts
.Triple
= llvm::Triple::normalize(Args
.getLastArgValue(OPT_triple
));
1564 // Use the host triple if unspecified.
1565 if (Opts
.Triple
.empty())
1566 Opts
.Triple
= llvm::sys::getHostTriple();
1571 void CompilerInvocation::CreateFromArgs(CompilerInvocation
&Res
,
1572 const char *const *ArgBegin
,
1573 const char *const *ArgEnd
,
1574 Diagnostic
&Diags
) {
1575 // Parse the arguments.
1576 llvm::OwningPtr
<OptTable
> Opts(createCC1OptTable());
1577 unsigned MissingArgIndex
, MissingArgCount
;
1578 llvm::OwningPtr
<InputArgList
> Args(
1579 Opts
->ParseArgs(ArgBegin
, ArgEnd
,MissingArgIndex
, MissingArgCount
));
1581 // Check for missing argument error.
1582 if (MissingArgCount
)
1583 Diags
.Report(diag::err_drv_missing_argument
)
1584 << Args
->getArgString(MissingArgIndex
) << MissingArgCount
;
1586 // Issue errors on unknown arguments.
1587 for (arg_iterator it
= Args
->filtered_begin(OPT_UNKNOWN
),
1588 ie
= Args
->filtered_end(); it
!= ie
; ++it
)
1589 Diags
.Report(diag::err_drv_unknown_argument
) << (*it
)->getAsString(*Args
);
1591 ParseAnalyzerArgs(Res
.getAnalyzerOpts(), *Args
, Diags
);
1592 ParseDependencyOutputArgs(Res
.getDependencyOutputOpts(), *Args
);
1593 ParseDiagnosticArgs(Res
.getDiagnosticOpts(), *Args
, Diags
);
1594 ParseFileSystemArgs(Res
.getFileSystemOpts(), *Args
);
1595 // FIXME: We shouldn't have to pass the DashX option around here
1596 InputKind DashX
= ParseFrontendArgs(Res
.getFrontendOpts(), *Args
, Diags
);
1597 ParseCodeGenArgs(Res
.getCodeGenOpts(), *Args
, DashX
, Diags
);
1598 ParseHeaderSearchArgs(Res
.getHeaderSearchOpts(), *Args
);
1599 if (DashX
!= IK_AST
&& DashX
!= IK_LLVM_IR
)
1600 ParseLangArgs(Res
.getLangOpts(), *Args
, DashX
, Diags
);
1601 // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
1602 // PCH file and find the original header name. Remove the need to do that in
1603 // ParsePreprocessorArgs and remove the FileManager
1604 // parameters from the function and the "FileManager.h" #include.
1605 FileManager
FileMgr(Res
.getFileSystemOpts());
1606 ParsePreprocessorArgs(Res
.getPreprocessorOpts(), *Args
, FileMgr
, Diags
);
1607 ParsePreprocessorOutputArgs(Res
.getPreprocessorOutputOpts(), *Args
);
1608 ParseTargetArgs(Res
.getTargetOpts(), *Args
);