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/System/Host.h"
30 #include "llvm/System/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_PreprocessedC
: return "cpp-output";
306 case IK_PreprocessedCXX
: return "c++-cpp-output";
307 case IK_PreprocessedObjC
: return "objective-c-cpp-output";
308 case IK_PreprocessedObjCXX
:return "objective-c++-cpp-output";
311 llvm_unreachable("Unexpected language kind!");
315 static const char *getActionName(frontend::ActionKind Kind
) {
317 case frontend::PluginAction
:
318 case frontend::InheritanceView
:
319 llvm_unreachable("Invalid kind!");
321 case frontend::ASTDump
: return "-ast-dump";
322 case frontend::ASTPrint
: return "-ast-print";
323 case frontend::ASTPrintXML
: return "-ast-print-xml";
324 case frontend::ASTView
: return "-ast-view";
325 case frontend::BoostCon
: return "-boostcon";
326 case frontend::CreateModule
: return "-create-module";
327 case frontend::DumpRawTokens
: return "-dump-raw-tokens";
328 case frontend::DumpTokens
: return "-dump-tokens";
329 case frontend::EmitAssembly
: return "-S";
330 case frontend::EmitBC
: return "-emit-llvm-bc";
331 case frontend::EmitHTML
: return "-emit-html";
332 case frontend::EmitLLVM
: return "-emit-llvm";
333 case frontend::EmitLLVMOnly
: return "-emit-llvm-only";
334 case frontend::EmitCodeGenOnly
: return "-emit-codegen-only";
335 case frontend::EmitObj
: return "-emit-obj";
336 case frontend::FixIt
: return "-fixit";
337 case frontend::GeneratePCH
: return "-emit-pch";
338 case frontend::GeneratePTH
: return "-emit-pth";
339 case frontend::InitOnly
: return "-init-only";
340 case frontend::ParseSyntaxOnly
: return "-fsyntax-only";
341 case frontend::PrintDeclContext
: return "-print-decl-contexts";
342 case frontend::PrintPreamble
: return "-print-preamble";
343 case frontend::PrintPreprocessedInput
: return "-E";
344 case frontend::RewriteMacros
: return "-rewrite-macros";
345 case frontend::RewriteObjC
: return "-rewrite-objc";
346 case frontend::RewriteTest
: return "-rewrite-test";
347 case frontend::RunAnalysis
: return "-analyze";
348 case frontend::RunPreprocessorOnly
: return "-Eonly";
351 llvm_unreachable("Unexpected language kind!");
355 static void FileSystemOptsToArgs(const FileSystemOptions
&Opts
,
356 std::vector
<std::string
> &Res
) {
357 if (!Opts
.WorkingDir
.empty()) {
358 Res
.push_back("-working-directory");
359 Res
.push_back(Opts
.WorkingDir
);
363 static void FrontendOptsToArgs(const FrontendOptions
&Opts
,
364 std::vector
<std::string
> &Res
) {
365 if (Opts
.DisableFree
)
366 Res
.push_back("-disable-free");
367 if (Opts
.RelocatablePCH
)
368 Res
.push_back("-relocatable-pch");
370 Res
.push_back("-chained-pch");
372 Res
.push_back("-help");
373 if (Opts
.ShowMacrosInCodeCompletion
)
374 Res
.push_back("-code-completion-macros");
375 if (Opts
.ShowCodePatternsInCodeCompletion
)
376 Res
.push_back("-code-completion-patterns");
377 if (!Opts
.ShowGlobalSymbolsInCodeCompletion
)
378 Res
.push_back("-no-code-completion-globals");
380 Res
.push_back("-print-stats");
382 Res
.push_back("-ftime-report");
383 if (Opts
.ShowVersion
)
384 Res
.push_back("-version");
385 if (Opts
.FixWhatYouCan
)
386 Res
.push_back("-fix-what-you-can");
388 bool NeedLang
= false;
389 for (unsigned i
= 0, e
= Opts
.Inputs
.size(); i
!= e
; ++i
)
390 if (FrontendOptions::getInputKindForExtension(Opts
.Inputs
[i
].second
) !=
391 Opts
.Inputs
[i
].first
)
395 Res
.push_back(getInputKindName(Opts
.Inputs
[0].first
));
397 for (unsigned i
= 0, e
= Opts
.Inputs
.size(); i
!= e
; ++i
) {
398 assert((!NeedLang
|| Opts
.Inputs
[i
].first
== Opts
.Inputs
[0].first
) &&
399 "Unable to represent this input vector!");
400 Res
.push_back(Opts
.Inputs
[i
].second
);
403 if (!Opts
.OutputFile
.empty()) {
405 Res
.push_back(Opts
.OutputFile
);
407 if (!Opts
.ViewClassInheritance
.empty()) {
408 Res
.push_back("-cxx-inheritance-view");
409 Res
.push_back(Opts
.ViewClassInheritance
);
411 if (!Opts
.CodeCompletionAt
.FileName
.empty()) {
412 Res
.push_back("-code-completion-at");
413 Res
.push_back(Opts
.CodeCompletionAt
.FileName
+ ":" +
414 llvm::utostr(Opts
.CodeCompletionAt
.Line
) + ":" +
415 llvm::utostr(Opts
.CodeCompletionAt
.Column
));
417 if (Opts
.ProgramAction
!= frontend::InheritanceView
&&
418 Opts
.ProgramAction
!= frontend::PluginAction
)
419 Res
.push_back(getActionName(Opts
.ProgramAction
));
420 if (!Opts
.ActionName
.empty()) {
421 Res
.push_back("-plugin");
422 Res
.push_back(Opts
.ActionName
);
423 for(unsigned i
= 0, e
= Opts
.PluginArgs
.size(); i
!= e
; ++i
) {
424 Res
.push_back("-plugin-arg-" + Opts
.ActionName
);
425 Res
.push_back(Opts
.PluginArgs
[i
]);
428 for (unsigned i
= 0, e
= Opts
.Plugins
.size(); i
!= e
; ++i
) {
429 Res
.push_back("-load");
430 Res
.push_back(Opts
.Plugins
[i
]);
432 for (unsigned i
= 0, e
= Opts
.ASTMergeFiles
.size(); i
!= e
; ++i
) {
433 Res
.push_back("-ast-merge");
434 Res
.push_back(Opts
.ASTMergeFiles
[i
]);
436 for (unsigned i
= 0, e
= Opts
.Modules
.size(); i
!= e
; ++i
) {
437 Res
.push_back("-import-module");
438 Res
.push_back(Opts
.Modules
[i
]);
440 for (unsigned i
= 0, e
= Opts
.LLVMArgs
.size(); i
!= e
; ++i
) {
441 Res
.push_back("-mllvm");
442 Res
.push_back(Opts
.LLVMArgs
[i
]);
446 static void HeaderSearchOptsToArgs(const HeaderSearchOptions
&Opts
,
447 std::vector
<std::string
> &Res
) {
448 if (Opts
.Sysroot
!= "/") {
449 Res
.push_back("-isysroot");
450 Res
.push_back(Opts
.Sysroot
);
453 for (unsigned i
= 0, e
= Opts
.CXXSystemIncludes
.size(); i
!= e
; ++i
) {
454 Res
.push_back("-cxx-system-include");
455 Res
.push_back(Opts
.CXXSystemIncludes
[i
]);
458 /// User specified include entries.
459 for (unsigned i
= 0, e
= Opts
.UserEntries
.size(); i
!= e
; ++i
) {
460 const HeaderSearchOptions::Entry
&E
= Opts
.UserEntries
[i
];
461 if (E
.IsFramework
&& (E
.Group
!= frontend::Angled
|| !E
.IsUserSupplied
))
462 llvm::report_fatal_error("Invalid option set!");
463 if (E
.IsUserSupplied
) {
464 if (E
.Group
== frontend::After
) {
465 Res
.push_back("-idirafter");
466 } else if (E
.Group
== frontend::Quoted
) {
467 Res
.push_back("-iquote");
468 } else if (E
.Group
== frontend::System
) {
469 Res
.push_back("-isystem");
471 assert(E
.Group
== frontend::Angled
&& "Invalid group!");
472 Res
.push_back(E
.IsFramework
? "-F" : "-I");
475 if (E
.Group
!= frontend::Angled
&& E
.Group
!= frontend::System
)
476 llvm::report_fatal_error("Invalid option set!");
477 Res
.push_back(E
.Group
== frontend::Angled
? "-iwithprefixbefore" :
480 Res
.push_back(E
.Path
);
483 if (!Opts
.EnvIncPath
.empty()) {
484 // FIXME: Provide an option for this, and move env detection to driver.
485 llvm::report_fatal_error("Not yet implemented!");
487 if (!Opts
.CEnvIncPath
.empty()) {
488 // FIXME: Provide an option for this, and move env detection to driver.
489 llvm::report_fatal_error("Not yet implemented!");
491 if (!Opts
.ObjCEnvIncPath
.empty()) {
492 // FIXME: Provide an option for this, and move env detection to driver.
493 llvm::report_fatal_error("Not yet implemented!");
495 if (!Opts
.CXXEnvIncPath
.empty()) {
496 // FIXME: Provide an option for this, and move env detection to driver.
497 llvm::report_fatal_error("Not yet implemented!");
499 if (!Opts
.ObjCXXEnvIncPath
.empty()) {
500 // FIXME: Provide an option for this, and move env detection to driver.
501 llvm::report_fatal_error("Not yet implemented!");
503 if (!Opts
.ResourceDir
.empty()) {
504 Res
.push_back("-resource-dir");
505 Res
.push_back(Opts
.ResourceDir
);
507 if (!Opts
.UseStandardIncludes
)
508 Res
.push_back("-nostdinc");
509 if (!Opts
.UseStandardCXXIncludes
)
510 Res
.push_back("-nostdinc++");
515 static void LangOptsToArgs(const LangOptions
&Opts
,
516 std::vector
<std::string
> &Res
) {
517 LangOptions DefaultLangOpts
;
519 // FIXME: Need to set -std to get all the implicit options.
521 // FIXME: We want to only pass options relative to the defaults, which
522 // requires constructing a target. :(
524 // It would be better to push the all target specific choices into the driver,
525 // so that everything below that was more uniform.
528 Res
.push_back("-trigraphs");
529 // Implicit based on the input kind:
530 // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
531 // Implicit based on the input language standard:
532 // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
533 if (Opts
.DollarIdents
)
534 Res
.push_back("-fdollars-in-identifiers");
535 if (Opts
.GNUMode
&& !Opts
.GNUKeywords
)
536 Res
.push_back("-fno-gnu-keywords");
537 if (!Opts
.GNUMode
&& Opts
.GNUKeywords
)
538 Res
.push_back("-fgnu-keywords");
540 Res
.push_back("-fms-extensions");
541 if (Opts
.MSCVersion
!= 0)
542 Res
.push_back("-fmsc-version=" + llvm::utostr(Opts
.MSCVersion
));
544 Res
.push_back("-fborland-extensions");
545 if (Opts
.ObjCNonFragileABI
)
546 Res
.push_back("-fobjc-nonfragile-abi");
547 if (Opts
.ObjCNonFragileABI2
)
548 Res
.push_back("-fobjc-nonfragile-abi2");
549 // NoInline is implicit.
550 if (!Opts
.CXXOperatorNames
)
551 Res
.push_back("-fno-operator-names");
552 if (Opts
.PascalStrings
)
553 Res
.push_back("-fpascal-strings");
554 if (Opts
.CatchUndefined
)
555 Res
.push_back("-fcatch-undefined-behavior");
556 if (Opts
.WritableStrings
)
557 Res
.push_back("-fwritable-strings");
558 if (Opts
.ConstStrings
)
559 Res
.push_back("-Wwrite-strings");
560 if (!Opts
.LaxVectorConversions
)
561 Res
.push_back("-fno-lax-vector-conversions");
563 Res
.push_back("-faltivec");
565 Res
.push_back("-fexceptions");
566 if (Opts
.SjLjExceptions
)
567 Res
.push_back("-fsjlj-exceptions");
569 Res
.push_back("-fno-rtti");
570 if (!Opts
.NeXTRuntime
)
571 Res
.push_back("-fgnu-runtime");
572 if (Opts
.Freestanding
)
573 Res
.push_back("-ffreestanding");
575 Res
.push_back("-fno-builtin");
576 if (!Opts
.AssumeSaneOperatorNew
)
577 Res
.push_back("-fno-assume-sane-operator-new");
578 if (!Opts
.ThreadsafeStatics
)
579 Res
.push_back("-fno-threadsafe-statics");
580 if (Opts
.POSIXThreads
)
581 Res
.push_back("-pthread");
583 Res
.push_back("-fblocks");
584 if (Opts
.EmitAllDecls
)
585 Res
.push_back("-femit-all-decls");
587 Res
.push_back("-fmath-errno");
588 switch (Opts
.getSignedOverflowBehavior()) {
589 case LangOptions::SOB_Undefined
: break;
590 case LangOptions::SOB_Defined
: Res
.push_back("-fwrapv"); break;
591 case LangOptions::SOB_Trapping
:
592 Res
.push_back("-ftrapv"); break;
593 if (!Opts
.OverflowHandler
.empty()) {
594 Res
.push_back("-ftrapv-handler");
595 Res
.push_back(Opts
.OverflowHandler
);
598 if (Opts
.HeinousExtensions
)
599 Res
.push_back("-fheinous-gnu-extensions");
600 // Optimize is implicit.
601 // OptimizeSize is implicit.
603 Res
.push_back("-static-define");
604 if (Opts
.DumpRecordLayouts
)
605 Res
.push_back("-fdump-record-layouts");
606 if (Opts
.DumpVTableLayouts
)
607 Res
.push_back("-fdump-vtable-layouts");
608 if (Opts
.NoBitFieldTypeAlign
)
609 Res
.push_back("-fno-bitfield-type-alignment");
610 if (Opts
.SjLjExceptions
)
611 Res
.push_back("-fsjlj-exceptions");
613 Res
.push_back("-pic-level");
614 Res
.push_back(llvm::utostr(Opts
.PICLevel
));
616 if (Opts
.ObjCGCBitmapPrint
)
617 Res
.push_back("-print-ivar-layout");
618 if (Opts
.NoConstantCFStrings
)
619 Res
.push_back("-fno-constant-cfstrings");
620 if (!Opts
.AccessControl
)
621 Res
.push_back("-fno-access-control");
622 if (!Opts
.CharIsSigned
)
623 Res
.push_back("-fno-signed-char");
625 Res
.push_back("-fshort-wchar");
626 if (!Opts
.ElideConstructors
)
627 Res
.push_back("-fno-elide-constructors");
628 if (Opts
.getGCMode() != LangOptions::NonGC
) {
629 if (Opts
.getGCMode() == LangOptions::HybridGC
) {
630 Res
.push_back("-fobjc-gc");
632 assert(Opts
.getGCMode() == LangOptions::GCOnly
&& "Invalid GC mode!");
633 Res
.push_back("-fobjc-gc-only");
636 if (Opts
.getVisibilityMode() != DefaultVisibility
) {
637 Res
.push_back("-fvisibility");
638 if (Opts
.getVisibilityMode() == HiddenVisibility
) {
639 Res
.push_back("hidden");
641 assert(Opts
.getVisibilityMode() == ProtectedVisibility
&&
642 "Invalid visibility!");
643 Res
.push_back("protected");
646 if (Opts
.InlineVisibilityHidden
)
647 Res
.push_back("-fvisibility-inlines-hidden");
649 if (Opts
.getStackProtectorMode() != 0) {
650 Res
.push_back("-stack-protector");
651 Res
.push_back(llvm::utostr(Opts
.getStackProtectorMode()));
653 if (Opts
.InstantiationDepth
!= DefaultLangOpts
.InstantiationDepth
) {
654 Res
.push_back("-ftemplate-depth");
655 Res
.push_back(llvm::utostr(Opts
.InstantiationDepth
));
657 if (!Opts
.ObjCConstantStringClass
.empty()) {
658 Res
.push_back("-fconstant-string-class");
659 Res
.push_back(Opts
.ObjCConstantStringClass
);
663 static void PreprocessorOptsToArgs(const PreprocessorOptions
&Opts
,
664 std::vector
<std::string
> &Res
) {
665 for (unsigned i
= 0, e
= Opts
.Macros
.size(); i
!= e
; ++i
)
666 Res
.push_back(std::string(Opts
.Macros
[i
].second
? "-U" : "-D") +
667 Opts
.Macros
[i
].first
);
668 for (unsigned i
= 0, e
= Opts
.Includes
.size(); i
!= e
; ++i
) {
669 // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
670 Res
.push_back("-include");
671 Res
.push_back(Opts
.Includes
[i
]);
673 for (unsigned i
= 0, e
= Opts
.MacroIncludes
.size(); i
!= e
; ++i
) {
674 Res
.push_back("-imacros");
675 Res
.push_back(Opts
.MacroIncludes
[i
]);
677 if (!Opts
.UsePredefines
)
678 Res
.push_back("-undef");
679 if (Opts
.DetailedRecord
)
680 Res
.push_back("-detailed-preprocessing-record");
681 if (!Opts
.ImplicitPCHInclude
.empty()) {
682 Res
.push_back("-include-pch");
683 Res
.push_back(Opts
.ImplicitPCHInclude
);
685 if (!Opts
.ImplicitPTHInclude
.empty()) {
686 Res
.push_back("-include-pth");
687 Res
.push_back(Opts
.ImplicitPTHInclude
);
689 if (!Opts
.TokenCache
.empty()) {
690 if (Opts
.ImplicitPTHInclude
.empty()) {
691 Res
.push_back("-token-cache");
692 Res
.push_back(Opts
.TokenCache
);
694 assert(Opts
.ImplicitPTHInclude
== Opts
.TokenCache
&&
695 "Unsupported option combination!");
697 for (unsigned i
= 0, e
= Opts
.RemappedFiles
.size(); i
!= e
; ++i
) {
698 Res
.push_back("-remap-file");
699 Res
.push_back(Opts
.RemappedFiles
[i
].first
+ ";" +
700 Opts
.RemappedFiles
[i
].second
);
704 static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions
&Opts
,
705 std::vector
<std::string
> &Res
) {
706 if (!Opts
.ShowCPP
&& !Opts
.ShowMacros
)
707 llvm::report_fatal_error("Invalid option combination!");
709 if (Opts
.ShowCPP
&& Opts
.ShowMacros
)
710 Res
.push_back("-dD");
711 else if (!Opts
.ShowCPP
&& Opts
.ShowMacros
)
712 Res
.push_back("-dM");
714 if (Opts
.ShowHeaderIncludes
)
716 if (!Opts
.ShowLineMarkers
)
718 if (Opts
.ShowComments
)
720 if (Opts
.ShowMacroComments
)
721 Res
.push_back("-CC");
724 static void TargetOptsToArgs(const TargetOptions
&Opts
,
725 std::vector
<std::string
> &Res
) {
726 Res
.push_back("-triple");
727 Res
.push_back(Opts
.Triple
);
728 if (!Opts
.CPU
.empty()) {
729 Res
.push_back("-target-cpu");
730 Res
.push_back(Opts
.CPU
);
732 if (!Opts
.ABI
.empty()) {
733 Res
.push_back("-target-abi");
734 Res
.push_back(Opts
.ABI
);
736 if (!Opts
.LinkerVersion
.empty()) {
737 Res
.push_back("-target-linker-version");
738 Res
.push_back(Opts
.LinkerVersion
);
740 if (!Opts
.CXXABI
.empty()) {
741 Res
.push_back("-cxx-abi");
742 Res
.push_back(Opts
.CXXABI
);
744 for (unsigned i
= 0, e
= Opts
.Features
.size(); i
!= e
; ++i
) {
745 Res
.push_back("-target-feature");
746 Res
.push_back(Opts
.Features
[i
]);
750 void CompilerInvocation::toArgs(std::vector
<std::string
> &Res
) {
751 AnalyzerOptsToArgs(getAnalyzerOpts(), Res
);
752 CodeGenOptsToArgs(getCodeGenOpts(), Res
);
753 DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res
);
754 DiagnosticOptsToArgs(getDiagnosticOpts(), Res
);
755 FileSystemOptsToArgs(getFileSystemOpts(), Res
);
756 FrontendOptsToArgs(getFrontendOpts(), Res
);
757 HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res
);
758 LangOptsToArgs(getLangOpts(), Res
);
759 PreprocessorOptsToArgs(getPreprocessorOpts(), Res
);
760 PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res
);
761 TargetOptsToArgs(getTargetOpts(), Res
);
764 //===----------------------------------------------------------------------===//
765 // Deserialization (to args)
766 //===----------------------------------------------------------------------===//
768 using namespace clang::driver
;
769 using namespace clang::driver::cc1options
;
773 static void ParseAnalyzerArgs(AnalyzerOptions
&Opts
, ArgList
&Args
,
775 using namespace cc1options
;
777 Opts
.AnalysisList
.clear();
778 #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) \
779 if (Args.hasArg(OPT_analysis_##NAME)) Opts.AnalysisList.push_back(NAME);
780 #include "clang/Frontend/Analyses.def"
782 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_store
)) {
783 llvm::StringRef Name
= A
->getValue(Args
);
784 AnalysisStores Value
= llvm::StringSwitch
<AnalysisStores
>(Name
)
785 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
786 .Case(CMDFLAG, NAME##Model)
787 #include "clang/Frontend/Analyses.def"
789 // FIXME: Error handling.
790 if (Value
== NumStores
)
791 Diags
.Report(diag::err_drv_invalid_value
)
792 << A
->getAsString(Args
) << Name
;
794 Opts
.AnalysisStoreOpt
= Value
;
797 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_constraints
)) {
798 llvm::StringRef Name
= A
->getValue(Args
);
799 AnalysisConstraints Value
= llvm::StringSwitch
<AnalysisConstraints
>(Name
)
800 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
801 .Case(CMDFLAG, NAME##Model)
802 #include "clang/Frontend/Analyses.def"
803 .Default(NumConstraints
);
804 // FIXME: Error handling.
805 if (Value
== NumConstraints
)
806 Diags
.Report(diag::err_drv_invalid_value
)
807 << A
->getAsString(Args
) << Name
;
809 Opts
.AnalysisConstraintsOpt
= Value
;
812 if (Arg
*A
= Args
.getLastArg(OPT_analyzer_output
)) {
813 llvm::StringRef Name
= A
->getValue(Args
);
814 AnalysisDiagClients Value
= llvm::StringSwitch
<AnalysisDiagClients
>(Name
)
815 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
816 .Case(CMDFLAG, PD_##NAME)
817 #include "clang/Frontend/Analyses.def"
818 .Default(NUM_ANALYSIS_DIAG_CLIENTS
);
819 // FIXME: Error handling.
820 if (Value
== NUM_ANALYSIS_DIAG_CLIENTS
)
821 Diags
.Report(diag::err_drv_invalid_value
)
822 << A
->getAsString(Args
) << Name
;
824 Opts
.AnalysisDiagOpt
= Value
;
827 Opts
.VisualizeEGDot
= Args
.hasArg(OPT_analyzer_viz_egraph_graphviz
);
828 Opts
.VisualizeEGUbi
= Args
.hasArg(OPT_analyzer_viz_egraph_ubigraph
);
829 Opts
.AnalyzeAll
= Args
.hasArg(OPT_analyzer_opt_analyze_headers
);
830 Opts
.AnalyzerDisplayProgress
= Args
.hasArg(OPT_analyzer_display_progress
);
831 Opts
.AnalyzeNestedBlocks
=
832 Args
.hasArg(OPT_analyzer_opt_analyze_nested_blocks
);
833 Opts
.AnalyzerStats
= Args
.hasArg(OPT_analysis_AnalyzerStats
);
834 Opts
.PurgeDead
= !Args
.hasArg(OPT_analyzer_no_purge_dead
);
835 Opts
.EagerlyAssume
= Args
.hasArg(OPT_analyzer_eagerly_assume
);
836 Opts
.AnalyzeSpecificFunction
= Args
.getLastArgValue(OPT_analyze_function
);
837 Opts
.UnoptimizedCFG
= Args
.hasArg(OPT_analysis_UnoptimizedCFG
);
838 Opts
.CFGAddImplicitDtors
= Args
.hasArg(OPT_analysis_CFGAddImplicitDtors
);
839 Opts
.CFGAddInitializers
= Args
.hasArg(OPT_analysis_CFGAddInitializers
);
840 Opts
.EnableExperimentalChecks
= Args
.hasArg(OPT_analyzer_experimental_checks
);
841 Opts
.EnableExperimentalInternalChecks
=
842 Args
.hasArg(OPT_analyzer_experimental_internal_checks
);
843 Opts
.TrimGraph
= Args
.hasArg(OPT_trim_egraph
);
844 Opts
.MaxNodes
= Args
.getLastArgIntValue(OPT_analyzer_max_nodes
, 150000,Diags
);
845 Opts
.MaxLoop
= Args
.getLastArgIntValue(OPT_analyzer_max_loop
, 4, Diags
);
846 Opts
.InlineCall
= Args
.hasArg(OPT_analyzer_inline_call
);
847 Opts
.IdempotentOps
= Args
.hasArg(OPT_analysis_WarnIdempotentOps
);
850 static void ParseCodeGenArgs(CodeGenOptions
&Opts
, ArgList
&Args
,
852 using namespace cc1options
;
854 if (Args
.hasArg(OPT_Os
))
855 Opts
.OptimizationLevel
= 2;
857 Opts
.OptimizationLevel
= Args
.getLastArgIntValue(OPT_O
, 0, Diags
);
858 if (Opts
.OptimizationLevel
> 3) {
859 Diags
.Report(diag::err_drv_invalid_value
)
860 << Args
.getLastArg(OPT_O
)->getAsString(Args
) << Opts
.OptimizationLevel
;
861 Opts
.OptimizationLevel
= 3;
865 // We must always run at least the always inlining pass.
866 Opts
.Inlining
= (Opts
.OptimizationLevel
> 1) ? CodeGenOptions::NormalInlining
867 : CodeGenOptions::OnlyAlwaysInlining
;
869 Opts
.DebugInfo
= Args
.hasArg(OPT_g
);
870 Opts
.LimitDebugInfo
= Args
.hasArg(OPT_flimit_debug_info
);
871 Opts
.DisableLLVMOpts
= Args
.hasArg(OPT_disable_llvm_optzns
);
872 Opts
.DisableRedZone
= Args
.hasArg(OPT_disable_red_zone
);
873 Opts
.RelaxedAliasing
= Args
.hasArg(OPT_relaxed_aliasing
);
874 Opts
.DwarfDebugFlags
= Args
.getLastArgValue(OPT_dwarf_debug_flags
);
875 Opts
.MergeAllConstants
= !Args
.hasArg(OPT_fno_merge_all_constants
);
876 Opts
.NoCommon
= Args
.hasArg(OPT_fno_common
);
877 Opts
.NoImplicitFloat
= Args
.hasArg(OPT_no_implicit_float
);
878 Opts
.OptimizeSize
= Args
.hasArg(OPT_Os
);
879 Opts
.SimplifyLibCalls
= !(Args
.hasArg(OPT_fno_builtin
) ||
880 Args
.hasArg(OPT_ffreestanding
));
881 Opts
.UnrollLoops
= Args
.hasArg(OPT_funroll_loops
) ||
882 (Opts
.OptimizationLevel
> 1 && !Opts
.OptimizeSize
);
884 Opts
.AsmVerbose
= Args
.hasArg(OPT_masm_verbose
);
885 Opts
.CXAAtExit
= !Args
.hasArg(OPT_fno_use_cxa_atexit
);
886 Opts
.CXXCtorDtorAliases
= Args
.hasArg(OPT_mconstructor_aliases
);
887 Opts
.CodeModel
= Args
.getLastArgValue(OPT_mcode_model
);
888 Opts
.DebugPass
= Args
.getLastArgValue(OPT_mdebug_pass
);
889 Opts
.DisableFPElim
= Args
.hasArg(OPT_mdisable_fp_elim
);
890 Opts
.FloatABI
= Args
.getLastArgValue(OPT_mfloat_abi
);
891 Opts
.HiddenWeakVTables
= Args
.hasArg(OPT_fhidden_weak_vtables
);
892 Opts
.LimitFloatPrecision
= Args
.getLastArgValue(OPT_mlimit_float_precision
);
893 Opts
.NoZeroInitializedInBSS
= Args
.hasArg(OPT_mno_zero_initialized_in_bss
);
894 Opts
.RelaxAll
= Args
.hasArg(OPT_mrelax_all
);
895 Opts
.OmitLeafFramePointer
= Args
.hasArg(OPT_momit_leaf_frame_pointer
);
896 Opts
.SoftFloat
= Args
.hasArg(OPT_msoft_float
);
897 Opts
.UnwindTables
= Args
.hasArg(OPT_munwind_tables
);
898 Opts
.RelocationModel
= Args
.getLastArgValue(OPT_mrelocation_model
, "pic");
900 Opts
.FunctionSections
= Args
.hasArg(OPT_ffunction_sections
);
901 Opts
.DataSections
= Args
.hasArg(OPT_fdata_sections
);
903 Opts
.MainFileName
= Args
.getLastArgValue(OPT_main_file_name
);
904 Opts
.VerifyModule
= !Args
.hasArg(OPT_disable_llvm_verifier
);
906 Opts
.InstrumentFunctions
= Args
.hasArg(OPT_finstrument_functions
);
908 if (Arg
*A
= Args
.getLastArg(OPT_fobjc_dispatch_method_EQ
)) {
909 llvm::StringRef Name
= A
->getValue(Args
);
910 unsigned Method
= llvm::StringSwitch
<unsigned>(Name
)
911 .Case("legacy", CodeGenOptions::Legacy
)
912 .Case("non-legacy", CodeGenOptions::NonLegacy
)
913 .Case("mixed", CodeGenOptions::Mixed
)
916 Diags
.Report(diag::err_drv_invalid_value
) << A
->getAsString(Args
) << Name
;
918 Opts
.ObjCDispatchMethod
= Method
;
922 static void ParseDependencyOutputArgs(DependencyOutputOptions
&Opts
,
924 using namespace cc1options
;
925 Opts
.OutputFile
= Args
.getLastArgValue(OPT_dependency_file
);
926 Opts
.Targets
= Args
.getAllArgValues(OPT_MT
);
927 Opts
.IncludeSystemHeaders
= Args
.hasArg(OPT_sys_header_deps
);
928 Opts
.UsePhonyTargets
= Args
.hasArg(OPT_MP
);
931 static void ParseDiagnosticArgs(DiagnosticOptions
&Opts
, ArgList
&Args
,
933 using namespace cc1options
;
934 Opts
.IgnoreWarnings
= Args
.hasArg(OPT_w
);
935 Opts
.NoRewriteMacros
= Args
.hasArg(OPT_Wno_rewrite_macros
);
936 Opts
.Pedantic
= Args
.hasArg(OPT_pedantic
);
937 Opts
.PedanticErrors
= Args
.hasArg(OPT_pedantic_errors
);
938 Opts
.ShowCarets
= !Args
.hasArg(OPT_fno_caret_diagnostics
);
939 Opts
.ShowColors
= Args
.hasArg(OPT_fcolor_diagnostics
);
940 Opts
.ShowColumn
= !Args
.hasArg(OPT_fno_show_column
);
941 Opts
.ShowFixits
= !Args
.hasArg(OPT_fno_diagnostics_fixit_info
);
942 Opts
.ShowLocation
= !Args
.hasArg(OPT_fno_show_source_location
);
943 Opts
.ShowOptionNames
= Args
.hasArg(OPT_fdiagnostics_show_option
);
945 llvm::StringRef ShowOverloads
=
946 Args
.getLastArgValue(OPT_fshow_overloads_EQ
, "all");
947 if (ShowOverloads
== "best")
948 Opts
.ShowOverloads
= Diagnostic::Ovl_Best
;
949 else if (ShowOverloads
== "all")
950 Opts
.ShowOverloads
= Diagnostic::Ovl_All
;
952 Diags
.Report(diag::err_drv_invalid_value
)
953 << Args
.getLastArg(OPT_fshow_overloads_EQ
)->getAsString(Args
)
956 llvm::StringRef ShowCategory
=
957 Args
.getLastArgValue(OPT_fdiagnostics_show_category
, "none");
958 if (ShowCategory
== "none")
959 Opts
.ShowCategories
= 0;
960 else if (ShowCategory
== "id")
961 Opts
.ShowCategories
= 1;
962 else if (ShowCategory
== "name")
963 Opts
.ShowCategories
= 2;
965 Diags
.Report(diag::err_drv_invalid_value
)
966 << Args
.getLastArg(OPT_fdiagnostics_show_category
)->getAsString(Args
)
969 Opts
.ShowSourceRanges
= Args
.hasArg(OPT_fdiagnostics_print_source_range_info
);
970 Opts
.ShowParseableFixits
= Args
.hasArg(OPT_fdiagnostics_parseable_fixits
);
971 Opts
.VerifyDiagnostics
= Args
.hasArg(OPT_verify
);
972 Opts
.ErrorLimit
= Args
.getLastArgIntValue(OPT_ferror_limit
, 0, Diags
);
973 Opts
.MacroBacktraceLimit
974 = Args
.getLastArgIntValue(OPT_fmacro_backtrace_limit
,
975 DiagnosticOptions::DefaultMacroBacktraceLimit
, Diags
);
976 Opts
.TemplateBacktraceLimit
977 = Args
.getLastArgIntValue(OPT_ftemplate_backtrace_limit
,
978 DiagnosticOptions::DefaultTemplateBacktraceLimit
,
980 Opts
.TabStop
= Args
.getLastArgIntValue(OPT_ftabstop
,
981 DiagnosticOptions::DefaultTabStop
, Diags
);
982 if (Opts
.TabStop
== 0 || Opts
.TabStop
> DiagnosticOptions::MaxTabStop
) {
983 Diags
.Report(diag::warn_ignoring_ftabstop_value
)
984 << Opts
.TabStop
<< DiagnosticOptions::DefaultTabStop
;
985 Opts
.TabStop
= DiagnosticOptions::DefaultTabStop
;
987 Opts
.MessageLength
= Args
.getLastArgIntValue(OPT_fmessage_length
, 0, Diags
);
988 Opts
.DumpBuildInformation
= Args
.getLastArgValue(OPT_dump_build_information
);
989 Opts
.Warnings
= Args
.getAllArgValues(OPT_W
);
992 static void ParseFileSystemArgs(FileSystemOptions
&Opts
, ArgList
&Args
) {
993 Opts
.WorkingDir
= Args
.getLastArgValue(OPT_working_directory
);
996 static InputKind
ParseFrontendArgs(FrontendOptions
&Opts
, ArgList
&Args
,
998 using namespace cc1options
;
999 Opts
.ProgramAction
= frontend::ParseSyntaxOnly
;
1000 if (const Arg
*A
= Args
.getLastArg(OPT_Action_Group
)) {
1001 switch (A
->getOption().getID()) {
1003 assert(0 && "Invalid option in group!");
1005 Opts
.ProgramAction
= frontend::ASTDump
; break;
1007 Opts
.ProgramAction
= frontend::ASTPrint
; break;
1008 case OPT_ast_print_xml
:
1009 Opts
.ProgramAction
= frontend::ASTPrintXML
; break;
1011 Opts
.ProgramAction
= frontend::ASTView
; break;
1013 Opts
.ProgramAction
= frontend::BoostCon
; break;
1014 case OPT_dump_raw_tokens
:
1015 Opts
.ProgramAction
= frontend::DumpRawTokens
; break;
1016 case OPT_dump_tokens
:
1017 Opts
.ProgramAction
= frontend::DumpTokens
; break;
1019 Opts
.ProgramAction
= frontend::EmitAssembly
; break;
1020 case OPT_emit_llvm_bc
:
1021 Opts
.ProgramAction
= frontend::EmitBC
; break;
1023 Opts
.ProgramAction
= frontend::EmitHTML
; break;
1025 Opts
.ProgramAction
= frontend::EmitLLVM
; break;
1026 case OPT_emit_llvm_only
:
1027 Opts
.ProgramAction
= frontend::EmitLLVMOnly
; break;
1028 case OPT_emit_codegen_only
:
1029 Opts
.ProgramAction
= frontend::EmitCodeGenOnly
; break;
1031 Opts
.ProgramAction
= frontend::EmitObj
; break;
1033 Opts
.FixItSuffix
= A
->getValue(Args
);
1036 Opts
.ProgramAction
= frontend::FixIt
; break;
1038 Opts
.ProgramAction
= frontend::GeneratePCH
; break;
1040 Opts
.ProgramAction
= frontend::GeneratePTH
; break;
1042 Opts
.ProgramAction
= frontend::InitOnly
; break;
1043 case OPT_fsyntax_only
:
1044 Opts
.ProgramAction
= frontend::ParseSyntaxOnly
; break;
1045 case OPT_print_decl_contexts
:
1046 Opts
.ProgramAction
= frontend::PrintDeclContext
; break;
1047 case OPT_print_preamble
:
1048 Opts
.ProgramAction
= frontend::PrintPreamble
; break;
1050 Opts
.ProgramAction
= frontend::PrintPreprocessedInput
; break;
1051 case OPT_rewrite_macros
:
1052 Opts
.ProgramAction
= frontend::RewriteMacros
; break;
1053 case OPT_rewrite_objc
:
1054 Opts
.ProgramAction
= frontend::RewriteObjC
; break;
1055 case OPT_rewrite_test
:
1056 Opts
.ProgramAction
= frontend::RewriteTest
; break;
1058 Opts
.ProgramAction
= frontend::RunAnalysis
; break;
1060 Opts
.ProgramAction
= frontend::RunPreprocessorOnly
; break;
1061 case OPT_create_module
:
1062 Opts
.ProgramAction
= frontend::CreateModule
; break;
1066 if (const Arg
* A
= Args
.getLastArg(OPT_plugin
)) {
1067 Opts
.Plugins
.push_back(A
->getValue(Args
,0));
1068 Opts
.ProgramAction
= frontend::PluginAction
;
1069 Opts
.ActionName
= A
->getValue(Args
);
1071 for (arg_iterator it
= Args
.filtered_begin(OPT_plugin_arg
),
1072 end
= Args
.filtered_end(); it
!= end
; ++it
) {
1073 if ((*it
)->getValue(Args
, 0) == Opts
.ActionName
)
1074 Opts
.PluginArgs
.push_back((*it
)->getValue(Args
, 1));
1078 if (const Arg
*A
= Args
.getLastArg(OPT_code_completion_at
)) {
1079 Opts
.CodeCompletionAt
=
1080 ParsedSourceLocation::FromString(A
->getValue(Args
));
1081 if (Opts
.CodeCompletionAt
.FileName
.empty())
1082 Diags
.Report(diag::err_drv_invalid_value
)
1083 << A
->getAsString(Args
) << A
->getValue(Args
);
1085 Opts
.DisableFree
= Args
.hasArg(OPT_disable_free
);
1087 Opts
.OutputFile
= Args
.getLastArgValue(OPT_o
);
1088 Opts
.Plugins
= Args
.getAllArgValues(OPT_load
);
1089 Opts
.RelocatablePCH
= Args
.hasArg(OPT_relocatable_pch
);
1090 Opts
.ChainedPCH
= Args
.hasArg(OPT_chained_pch
);
1091 Opts
.ShowHelp
= Args
.hasArg(OPT_help
);
1092 Opts
.ShowMacrosInCodeCompletion
= Args
.hasArg(OPT_code_completion_macros
);
1093 Opts
.ShowCodePatternsInCodeCompletion
1094 = Args
.hasArg(OPT_code_completion_patterns
);
1095 Opts
.ShowGlobalSymbolsInCodeCompletion
1096 = !Args
.hasArg(OPT_no_code_completion_globals
);
1097 Opts
.ShowStats
= Args
.hasArg(OPT_print_stats
);
1098 Opts
.ShowTimers
= Args
.hasArg(OPT_ftime_report
);
1099 Opts
.ShowVersion
= Args
.hasArg(OPT_version
);
1100 Opts
.ViewClassInheritance
= Args
.getLastArgValue(OPT_cxx_inheritance_view
);
1101 Opts
.ASTMergeFiles
= Args
.getAllArgValues(OPT_ast_merge
);
1102 Opts
.LLVMArgs
= Args
.getAllArgValues(OPT_mllvm
);
1103 Opts
.FixWhatYouCan
= Args
.hasArg(OPT_fix_what_you_can
);
1104 Opts
.Modules
= Args
.getAllArgValues(OPT_import_module
);
1106 InputKind DashX
= IK_None
;
1107 if (const Arg
*A
= Args
.getLastArg(OPT_x
)) {
1108 DashX
= llvm::StringSwitch
<InputKind
>(A
->getValue(Args
))
1110 .Case("cl", IK_OpenCL
)
1112 .Case("cl", IK_OpenCL
)
1113 .Case("c++", IK_CXX
)
1114 .Case("objective-c", IK_ObjC
)
1115 .Case("objective-c++", IK_ObjCXX
)
1116 .Case("cpp-output", IK_PreprocessedC
)
1117 .Case("assembler-with-cpp", IK_Asm
)
1118 .Case("c++-cpp-output", IK_PreprocessedCXX
)
1119 .Case("objective-c-cpp-output", IK_PreprocessedObjC
)
1120 .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX
)
1121 .Case("c-header", IK_C
)
1122 .Case("objective-c-header", IK_ObjC
)
1123 .Case("c++-header", IK_CXX
)
1124 .Case("objective-c++-header", IK_ObjCXX
)
1125 .Case("ast", IK_AST
)
1126 .Case("ir", IK_LLVM_IR
)
1128 if (DashX
== IK_None
)
1129 Diags
.Report(diag::err_drv_invalid_value
)
1130 << A
->getAsString(Args
) << A
->getValue(Args
);
1133 // '-' is the default input if none is given.
1134 std::vector
<std::string
> Inputs
= Args
.getAllArgValues(OPT_INPUT
);
1135 Opts
.Inputs
.clear();
1137 Inputs
.push_back("-");
1138 for (unsigned i
= 0, e
= Inputs
.size(); i
!= e
; ++i
) {
1139 InputKind IK
= DashX
;
1140 if (IK
== IK_None
) {
1141 IK
= FrontendOptions::getInputKindForExtension(
1142 llvm::StringRef(Inputs
[i
]).rsplit('.').second
);
1143 // FIXME: Remove this hack.
1147 Opts
.Inputs
.push_back(std::make_pair(IK
, Inputs
[i
]));
1153 std::string
CompilerInvocation::GetResourcesPath(const char *Argv0
,
1155 llvm::sys::Path P
= llvm::sys::Path::GetMainExecutable(Argv0
, MainAddr
);
1158 P
.eraseComponent(); // Remove /clang from foo/bin/clang
1159 P
.eraseComponent(); // Remove /bin from foo/bin
1161 // Get foo/lib/clang/<version>/include
1162 P
.appendComponent("lib");
1163 P
.appendComponent("clang");
1164 P
.appendComponent(CLANG_VERSION_STRING
);
1170 static void ParseHeaderSearchArgs(HeaderSearchOptions
&Opts
, ArgList
&Args
) {
1171 using namespace cc1options
;
1172 Opts
.CXXSystemIncludes
= Args
.getAllArgValues(OPT_cxx_system_include
);
1173 Opts
.Sysroot
= Args
.getLastArgValue(OPT_isysroot
, "/");
1174 Opts
.Verbose
= Args
.hasArg(OPT_v
);
1175 Opts
.UseBuiltinIncludes
= !Args
.hasArg(OPT_nobuiltininc
);
1176 Opts
.UseStandardIncludes
= !Args
.hasArg(OPT_nostdinc
);
1177 Opts
.UseStandardCXXIncludes
= !Args
.hasArg(OPT_nostdincxx
);
1178 Opts
.ResourceDir
= Args
.getLastArgValue(OPT_resource_dir
);
1180 // Add -I... and -F... options in order.
1181 for (arg_iterator it
= Args
.filtered_begin(OPT_I
, OPT_F
),
1182 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1183 Opts
.AddPath((*it
)->getValue(Args
), frontend::Angled
, true,
1184 /*IsFramework=*/ (*it
)->getOption().matches(OPT_F
), true);
1186 // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1187 llvm::StringRef Prefix
= ""; // FIXME: This isn't the correct default prefix.
1188 for (arg_iterator it
= Args
.filtered_begin(OPT_iprefix
, OPT_iwithprefix
,
1189 OPT_iwithprefixbefore
),
1190 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1192 if (A
->getOption().matches(OPT_iprefix
))
1193 Prefix
= A
->getValue(Args
);
1194 else if (A
->getOption().matches(OPT_iwithprefix
))
1195 Opts
.AddPath(Prefix
.str() + A
->getValue(Args
),
1196 frontend::System
, false, false, true);
1198 Opts
.AddPath(Prefix
.str() + A
->getValue(Args
),
1199 frontend::Angled
, false, false, true);
1202 for (arg_iterator it
= Args
.filtered_begin(OPT_idirafter
),
1203 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1204 Opts
.AddPath((*it
)->getValue(Args
), frontend::After
, true, false, true);
1205 for (arg_iterator it
= Args
.filtered_begin(OPT_iquote
),
1206 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1207 Opts
.AddPath((*it
)->getValue(Args
), frontend::Quoted
, true, false, true);
1208 for (arg_iterator it
= Args
.filtered_begin(OPT_isystem
, OPT_iwithsysroot
),
1209 ie
= Args
.filtered_end(); it
!= ie
; ++it
)
1210 Opts
.AddPath((*it
)->getValue(Args
), frontend::System
, true, false,
1211 (*it
)->getOption().matches(OPT_iwithsysroot
));
1213 // FIXME: Need options for the various environment variables!
1216 static void ParseLangArgs(LangOptions
&Opts
, ArgList
&Args
, InputKind IK
,
1217 Diagnostic
&Diags
) {
1218 // FIXME: Cleanup per-file based stuff.
1220 // Set some properties which depend soley on the input kind; it would be nice
1221 // to move these to the language standard, and have the driver resolve the
1222 // input kind + language standard.
1224 Opts
.AsmPreprocessor
= 1;
1225 } else if (IK
== IK_ObjC
||
1227 IK
== IK_PreprocessedObjC
||
1228 IK
== IK_PreprocessedObjCXX
) {
1229 Opts
.ObjC1
= Opts
.ObjC2
= 1;
1232 LangStandard::Kind LangStd
= LangStandard::lang_unspecified
;
1233 if (const Arg
*A
= Args
.getLastArg(OPT_std_EQ
)) {
1234 LangStd
= llvm::StringSwitch
<LangStandard::Kind
>(A
->getValue(Args
))
1235 #define LANGSTANDARD(id, name, desc, features) \
1236 .Case(name, LangStandard::lang_##id)
1237 #include "clang/Frontend/LangStandards.def"
1238 .Default(LangStandard::lang_unspecified
);
1239 if (LangStd
== LangStandard::lang_unspecified
)
1240 Diags
.Report(diag::err_drv_invalid_value
)
1241 << A
->getAsString(Args
) << A
->getValue(Args
);
1244 if (LangStd
== LangStandard::lang_unspecified
) {
1245 // Based on the base language, pick one.
1250 assert(0 && "Invalid input kind!");
1252 LangStd
= LangStandard::lang_opencl
;
1256 case IK_PreprocessedC
:
1258 case IK_PreprocessedObjC
:
1259 LangStd
= LangStandard::lang_gnu99
;
1262 case IK_PreprocessedCXX
:
1264 case IK_PreprocessedObjCXX
:
1265 LangStd
= LangStandard::lang_gnucxx98
;
1270 const LangStandard
&Std
= LangStandard::getLangStandardForKind(LangStd
);
1271 Opts
.BCPLComment
= Std
.hasBCPLComments();
1272 Opts
.C99
= Std
.isC99();
1273 Opts
.CPlusPlus
= Std
.isCPlusPlus();
1274 Opts
.CPlusPlus0x
= Std
.isCPlusPlus0x();
1275 Opts
.Digraphs
= Std
.hasDigraphs();
1276 Opts
.GNUMode
= Std
.isGNUMode();
1277 Opts
.GNUInline
= !Std
.isC99();
1278 Opts
.HexFloats
= Std
.hasHexFloats();
1279 Opts
.ImplicitInt
= Std
.hasImplicitInt();
1281 // OpenCL has some additional defaults.
1282 if (LangStd
== LangStandard::lang_opencl
) {
1285 Opts
.CXXOperatorNames
= 1;
1286 Opts
.LaxVectorConversions
= 1;
1289 // OpenCL and C++ both have bool, true, false keywords.
1290 Opts
.Bool
= Opts
.OpenCL
|| Opts
.CPlusPlus
;
1292 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1293 // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1294 // while a subset (the non-C++ GNU keywords) is provided by GCC's
1295 // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1296 // name, as it doesn't seem a useful distinction.
1297 Opts
.GNUKeywords
= Args
.hasFlag(OPT_fgnu_keywords
, OPT_fno_gnu_keywords
,
1301 Opts
.CXXOperatorNames
= !Args
.hasArg(OPT_fno_operator_names
);
1303 if (Args
.hasArg(OPT_fobjc_gc_only
))
1304 Opts
.setGCMode(LangOptions::GCOnly
);
1305 else if (Args
.hasArg(OPT_fobjc_gc
))
1306 Opts
.setGCMode(LangOptions::HybridGC
);
1308 if (Args
.hasArg(OPT_print_ivar_layout
))
1309 Opts
.ObjCGCBitmapPrint
= 1;
1310 if (Args
.hasArg(OPT_fno_constant_cfstrings
))
1311 Opts
.NoConstantCFStrings
= 1;
1313 if (Args
.hasArg(OPT_faltivec
))
1316 if (Args
.hasArg(OPT_pthread
))
1317 Opts
.POSIXThreads
= 1;
1319 llvm::StringRef Vis
= Args
.getLastArgValue(OPT_fvisibility
, "default");
1320 if (Vis
== "default")
1321 Opts
.setVisibilityMode(DefaultVisibility
);
1322 else if (Vis
== "hidden")
1323 Opts
.setVisibilityMode(HiddenVisibility
);
1324 else if (Vis
== "protected")
1325 Opts
.setVisibilityMode(ProtectedVisibility
);
1327 Diags
.Report(diag::err_drv_invalid_value
)
1328 << Args
.getLastArg(OPT_fvisibility
)->getAsString(Args
) << Vis
;
1330 if (Args
.hasArg(OPT_fvisibility_inlines_hidden
))
1331 Opts
.InlineVisibilityHidden
= 1;
1333 if (Args
.hasArg(OPT_ftrapv
)) {
1334 Opts
.setSignedOverflowBehavior(LangOptions::SOB_Trapping
);
1335 // Set the handler, if one is specified.
1336 Opts
.OverflowHandler
=
1337 Args
.getLastArgValue(OPT_ftrapv_handler
);
1339 else if (Args
.hasArg(OPT_fwrapv
))
1340 Opts
.setSignedOverflowBehavior(LangOptions::SOB_Defined
);
1342 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1343 // is specified, or -std is set to a conforming mode.
1344 Opts
.Trigraphs
= !Opts
.GNUMode
;
1345 if (Args
.hasArg(OPT_trigraphs
))
1348 Opts
.DollarIdents
= Args
.hasFlag(OPT_fdollars_in_identifiers
,
1349 OPT_fno_dollars_in_identifiers
,
1350 !Opts
.AsmPreprocessor
);
1351 Opts
.PascalStrings
= Args
.hasArg(OPT_fpascal_strings
);
1352 Opts
.Microsoft
= Args
.hasArg(OPT_fms_extensions
);
1353 Opts
.MSCVersion
= Args
.getLastArgIntValue(OPT_fmsc_version
, 0, Diags
);
1354 Opts
.Borland
= Args
.hasArg(OPT_fborland_extensions
);
1355 Opts
.WritableStrings
= Args
.hasArg(OPT_fwritable_strings
);
1356 Opts
.ConstStrings
= Args
.hasArg(OPT_Wwrite_strings
);
1357 if (Args
.hasArg(OPT_fno_lax_vector_conversions
))
1358 Opts
.LaxVectorConversions
= 0;
1359 if (Args
.hasArg(OPT_fno_threadsafe_statics
))
1360 Opts
.ThreadsafeStatics
= 0;
1361 Opts
.Exceptions
= Args
.hasArg(OPT_fexceptions
);
1362 Opts
.RTTI
= !Args
.hasArg(OPT_fno_rtti
);
1363 Opts
.Blocks
= Args
.hasArg(OPT_fblocks
);
1364 Opts
.CharIsSigned
= !Args
.hasArg(OPT_fno_signed_char
);
1365 Opts
.ShortWChar
= Args
.hasArg(OPT_fshort_wchar
);
1366 Opts
.ShortEnums
= Args
.hasArg(OPT_fshort_enums
);
1367 Opts
.Freestanding
= Args
.hasArg(OPT_ffreestanding
);
1368 Opts
.NoBuiltin
= Args
.hasArg(OPT_fno_builtin
) || Opts
.Freestanding
;
1369 Opts
.AssumeSaneOperatorNew
= !Args
.hasArg(OPT_fno_assume_sane_operator_new
);
1370 Opts
.HeinousExtensions
= Args
.hasArg(OPT_fheinous_gnu_extensions
);
1371 Opts
.AccessControl
= !Args
.hasArg(OPT_fno_access_control
);
1372 Opts
.ElideConstructors
= !Args
.hasArg(OPT_fno_elide_constructors
);
1373 Opts
.MathErrno
= Args
.hasArg(OPT_fmath_errno
);
1374 Opts
.InstantiationDepth
= Args
.getLastArgIntValue(OPT_ftemplate_depth
, 1024,
1376 Opts
.NumLargeByValueCopy
= Args
.getLastArgIntValue(OPT_Wlarge_by_value_copy
,
1378 Opts
.NeXTRuntime
= !Args
.hasArg(OPT_fgnu_runtime
);
1379 Opts
.ObjCConstantStringClass
=
1380 Args
.getLastArgValue(OPT_fconstant_string_class
);
1381 Opts
.ObjCNonFragileABI
= Args
.hasArg(OPT_fobjc_nonfragile_abi
);
1382 Opts
.ObjCNonFragileABI2
= Args
.hasArg(OPT_fobjc_nonfragile_abi2
);
1383 if (Opts
.ObjCNonFragileABI2
)
1384 Opts
.ObjCNonFragileABI
= true;
1385 Opts
.CatchUndefined
= Args
.hasArg(OPT_fcatch_undefined_behavior
);
1386 Opts
.EmitAllDecls
= Args
.hasArg(OPT_femit_all_decls
);
1387 Opts
.PICLevel
= Args
.getLastArgIntValue(OPT_pic_level
, 0, Diags
);
1388 Opts
.SjLjExceptions
= Args
.hasArg(OPT_fsjlj_exceptions
);
1389 Opts
.Static
= Args
.hasArg(OPT_static_define
);
1390 Opts
.DumpRecordLayouts
= Args
.hasArg(OPT_fdump_record_layouts
);
1391 Opts
.DumpVTableLayouts
= Args
.hasArg(OPT_fdump_vtable_layouts
);
1392 Opts
.SpellChecking
= !Args
.hasArg(OPT_fno_spell_checking
);
1393 Opts
.NoBitFieldTypeAlign
= Args
.hasArg(OPT_fno_bitfield_type_align
);
1394 Opts
.OptimizeSize
= 0;
1396 // FIXME: Eliminate this dependency.
1398 Args
.hasArg(OPT_Os
) ? 2 : Args
.getLastArgIntValue(OPT_O
, 0, Diags
);
1399 Opts
.Optimize
= Opt
!= 0;
1401 // This is the __NO_INLINE__ define, which just depends on things like the
1402 // optimization level and -fno-inline, not actually whether the backend has
1403 // inlining enabled.
1405 // FIXME: This is affected by other options (-fno-inline).
1406 Opts
.NoInline
= !Opt
;
1408 unsigned SSP
= Args
.getLastArgIntValue(OPT_stack_protector
, 0, Diags
);
1411 Diags
.Report(diag::err_drv_invalid_value
)
1412 << Args
.getLastArg(OPT_stack_protector
)->getAsString(Args
) << SSP
;
1414 case 0: Opts
.setStackProtectorMode(LangOptions::SSPOff
); break;
1415 case 1: Opts
.setStackProtectorMode(LangOptions::SSPOn
); break;
1416 case 2: Opts
.setStackProtectorMode(LangOptions::SSPReq
); break;
1420 static void ParsePreprocessorArgs(PreprocessorOptions
&Opts
, ArgList
&Args
,
1421 FileManager
&FileMgr
,
1422 const FileSystemOptions
&FSOpts
,
1423 Diagnostic
&Diags
) {
1424 using namespace cc1options
;
1425 Opts
.ImplicitPCHInclude
= Args
.getLastArgValue(OPT_include_pch
);
1426 Opts
.ImplicitPTHInclude
= Args
.getLastArgValue(OPT_include_pth
);
1427 if (const Arg
*A
= Args
.getLastArg(OPT_token_cache
))
1428 Opts
.TokenCache
= A
->getValue(Args
);
1430 Opts
.TokenCache
= Opts
.ImplicitPTHInclude
;
1431 Opts
.UsePredefines
= !Args
.hasArg(OPT_undef
);
1432 Opts
.DetailedRecord
= Args
.hasArg(OPT_detailed_preprocessing_record
);
1433 Opts
.DisablePCHValidation
= Args
.hasArg(OPT_fno_validate_pch
);
1435 Opts
.DumpDeserializedPCHDecls
= Args
.hasArg(OPT_dump_deserialized_pch_decls
);
1436 for (arg_iterator it
= Args
.filtered_begin(OPT_error_on_deserialized_pch_decl
),
1437 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1439 Opts
.DeserializedPCHDeclsToErrorOn
.insert(A
->getValue(Args
));
1442 if (const Arg
*A
= Args
.getLastArg(OPT_preamble_bytes_EQ
)) {
1443 llvm::StringRef
Value(A
->getValue(Args
));
1444 size_t Comma
= Value
.find(',');
1446 unsigned EndOfLine
= 0;
1448 if (Comma
== llvm::StringRef::npos
||
1449 Value
.substr(0, Comma
).getAsInteger(10, Bytes
) ||
1450 Value
.substr(Comma
+ 1).getAsInteger(10, EndOfLine
))
1451 Diags
.Report(diag::err_drv_preamble_format
);
1453 Opts
.PrecompiledPreambleBytes
.first
= Bytes
;
1454 Opts
.PrecompiledPreambleBytes
.second
= (EndOfLine
!= 0);
1458 // Add macros from the command line.
1459 for (arg_iterator it
= Args
.filtered_begin(OPT_D
, OPT_U
),
1460 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1461 if ((*it
)->getOption().matches(OPT_D
))
1462 Opts
.addMacroDef((*it
)->getValue(Args
));
1464 Opts
.addMacroUndef((*it
)->getValue(Args
));
1467 Opts
.MacroIncludes
= Args
.getAllArgValues(OPT_imacros
);
1469 // Add the ordered list of -includes.
1470 for (arg_iterator it
= Args
.filtered_begin(OPT_include
, OPT_include_pch
,
1472 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1474 // PCH is handled specially, we need to extra the original include path.
1475 if (A
->getOption().matches(OPT_include_pch
)) {
1476 std::string OriginalFile
=
1477 ASTReader::getOriginalSourceFile(A
->getValue(Args
), FileMgr
, FSOpts
,
1479 if (OriginalFile
.empty())
1482 Opts
.Includes
.push_back(OriginalFile
);
1484 Opts
.Includes
.push_back(A
->getValue(Args
));
1487 // Include 'altivec.h' if -faltivec option present
1488 if (Args
.hasArg(OPT_faltivec
))
1489 Opts
.Includes
.push_back("altivec.h");
1491 for (arg_iterator it
= Args
.filtered_begin(OPT_remap_file
),
1492 ie
= Args
.filtered_end(); it
!= ie
; ++it
) {
1494 std::pair
<llvm::StringRef
,llvm::StringRef
> Split
=
1495 llvm::StringRef(A
->getValue(Args
)).split(';');
1497 if (Split
.second
.empty()) {
1498 Diags
.Report(diag::err_drv_invalid_remap_file
) << A
->getAsString(Args
);
1502 Opts
.addRemappedFile(Split
.first
, Split
.second
);
1506 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions
&Opts
,
1508 using namespace cc1options
;
1509 Opts
.ShowCPP
= !Args
.hasArg(OPT_dM
);
1510 Opts
.ShowComments
= Args
.hasArg(OPT_C
);
1511 Opts
.ShowHeaderIncludes
= Args
.hasArg(OPT_H
);
1512 Opts
.ShowLineMarkers
= !Args
.hasArg(OPT_P
);
1513 Opts
.ShowMacroComments
= Args
.hasArg(OPT_CC
);
1514 Opts
.ShowMacros
= Args
.hasArg(OPT_dM
) || Args
.hasArg(OPT_dD
);
1517 static void ParseTargetArgs(TargetOptions
&Opts
, ArgList
&Args
) {
1518 using namespace cc1options
;
1519 Opts
.ABI
= Args
.getLastArgValue(OPT_target_abi
);
1520 Opts
.CXXABI
= Args
.getLastArgValue(OPT_cxx_abi
);
1521 Opts
.CPU
= Args
.getLastArgValue(OPT_target_cpu
);
1522 Opts
.Features
= Args
.getAllArgValues(OPT_target_feature
);
1523 Opts
.LinkerVersion
= Args
.getLastArgValue(OPT_target_linker_version
);
1524 Opts
.Triple
= llvm::Triple::normalize(Args
.getLastArgValue(OPT_triple
));
1526 // Use the host triple if unspecified.
1527 if (Opts
.Triple
.empty())
1528 Opts
.Triple
= llvm::sys::getHostTriple();
1533 void CompilerInvocation::CreateFromArgs(CompilerInvocation
&Res
,
1534 const char* const *ArgBegin
,
1535 const char* const *ArgEnd
,
1536 Diagnostic
&Diags
) {
1537 // Parse the arguments.
1538 llvm::OwningPtr
<OptTable
> Opts(createCC1OptTable());
1539 unsigned MissingArgIndex
, MissingArgCount
;
1540 llvm::OwningPtr
<InputArgList
> Args(
1541 Opts
->ParseArgs(ArgBegin
, ArgEnd
,MissingArgIndex
, MissingArgCount
));
1543 // Check for missing argument error.
1544 if (MissingArgCount
)
1545 Diags
.Report(diag::err_drv_missing_argument
)
1546 << Args
->getArgString(MissingArgIndex
) << MissingArgCount
;
1548 // Issue errors on unknown arguments.
1549 for (arg_iterator it
= Args
->filtered_begin(OPT_UNKNOWN
),
1550 ie
= Args
->filtered_end(); it
!= ie
; ++it
)
1551 Diags
.Report(diag::err_drv_unknown_argument
) << (*it
)->getAsString(*Args
);
1553 ParseAnalyzerArgs(Res
.getAnalyzerOpts(), *Args
, Diags
);
1554 ParseCodeGenArgs(Res
.getCodeGenOpts(), *Args
, Diags
);
1555 ParseDependencyOutputArgs(Res
.getDependencyOutputOpts(), *Args
);
1556 ParseDiagnosticArgs(Res
.getDiagnosticOpts(), *Args
, Diags
);
1557 ParseFileSystemArgs(Res
.getFileSystemOpts(), *Args
);
1558 InputKind DashX
= ParseFrontendArgs(Res
.getFrontendOpts(), *Args
, Diags
);
1559 ParseHeaderSearchArgs(Res
.getHeaderSearchOpts(), *Args
);
1560 if (DashX
!= IK_AST
&& DashX
!= IK_LLVM_IR
)
1561 ParseLangArgs(Res
.getLangOpts(), *Args
, DashX
, Diags
);
1562 // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
1563 // PCH file and find the original header name. Remove the need to do that in
1564 // ParsePreprocessorArgs and remove the FileManager & FileSystemOptions
1565 // parameters from the function and the "FileManager.h" #include.
1566 FileManager
FileMgr(Res
.getFileSystemOpts());
1567 ParsePreprocessorArgs(Res
.getPreprocessorOpts(), *Args
,
1568 FileMgr
, Res
.getFileSystemOpts(), Diags
);
1569 ParsePreprocessorOutputArgs(Res
.getPreprocessorOutputOpts(), *Args
);
1570 ParseTargetArgs(Res
.getTargetOpts(), *Args
);