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