xref: /llvm-project/clang/lib/Frontend/CompilerInvocation.cpp (revision c3333e879f19f9758f3cbe6bc07c195b3576d68a)
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 //===----------------------------------------------------------------------===//
34 // Initialization.
35 //===----------------------------------------------------------------------===//
36 
37 CompilerInvocationBase::CompilerInvocationBase()
38   : LangOpts(new LangOptions()) {}
39 
40 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
41   : LangOpts(new LangOptions(*X.getLangOpts())) {}
42 
43 //===----------------------------------------------------------------------===//
44 // Utility functions.
45 //===----------------------------------------------------------------------===//
46 
47 static const char *getAnalysisStoreName(AnalysisStores Kind) {
48   switch (Kind) {
49   default:
50     llvm_unreachable("Unknown analysis store!");
51 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
52   case NAME##Model: return CMDFLAG;
53 #include "clang/Frontend/Analyses.def"
54   }
55 }
56 
57 static const char *getAnalysisConstraintName(AnalysisConstraints Kind) {
58   switch (Kind) {
59   default:
60     llvm_unreachable("Unknown analysis constraints!");
61 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
62   case NAME##Model: return CMDFLAG;
63 #include "clang/Frontend/Analyses.def"
64   }
65 }
66 
67 static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) {
68   switch (Kind) {
69   default:
70     llvm_unreachable("Unknown analysis client!");
71 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
72   case PD_##NAME: return CMDFLAG;
73 #include "clang/Frontend/Analyses.def"
74   }
75 }
76 
77 static const char *getAnalysisPurgeModeName(AnalysisPurgeMode Kind) {
78   switch (Kind) {
79   default:
80     llvm_unreachable("Unknown analysis client!");
81 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
82   case NAME: return CMDFLAG;
83 #include "clang/Frontend/Analyses.def"
84   }
85 }
86 
87 //===----------------------------------------------------------------------===//
88 // Serialization (to args)
89 //===----------------------------------------------------------------------===//
90 
91 static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts,
92                                std::vector<std::string> &Res) {
93   if (Opts.ShowCheckerHelp)
94     Res.push_back("-analyzer-checker-help");
95   if (Opts.AnalysisStoreOpt != RegionStoreModel) {
96     Res.push_back("-analyzer-store");
97     Res.push_back(getAnalysisStoreName(Opts.AnalysisStoreOpt));
98   }
99   if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {
100     Res.push_back("-analyzer-constraints");
101     Res.push_back(getAnalysisConstraintName(Opts.AnalysisConstraintsOpt));
102   }
103   if (Opts.AnalysisDiagOpt != PD_HTML) {
104     Res.push_back("-analyzer-output");
105     Res.push_back(getAnalysisDiagClientName(Opts.AnalysisDiagOpt));
106   }
107   if (Opts.AnalysisPurgeOpt != PurgeStmt) {
108     Res.push_back("-analyzer-purge");
109     Res.push_back(getAnalysisPurgeModeName(Opts.AnalysisPurgeOpt));
110   }
111   if (!Opts.AnalyzeSpecificFunction.empty()) {
112     Res.push_back("-analyze-function");
113     Res.push_back(Opts.AnalyzeSpecificFunction);
114   }
115   if (Opts.AnalyzeAll)
116     Res.push_back("-analyzer-opt-analyze-headers");
117   if (Opts.AnalyzerDisplayProgress)
118     Res.push_back("-analyzer-display-progress");
119   if (Opts.AnalyzeNestedBlocks)
120     Res.push_back("-analyzer-opt-analyze-nested-blocks");
121   if (Opts.EagerlyAssume)
122     Res.push_back("-analyzer-eagerly-assume");
123   if (Opts.TrimGraph)
124     Res.push_back("-trim-egraph");
125   if (Opts.VisualizeEGDot)
126     Res.push_back("-analyzer-viz-egraph-graphviz");
127   if (Opts.VisualizeEGUbi)
128     Res.push_back("-analyzer-viz-egraph-ubigraph");
129 
130   for (unsigned i = 0, e = Opts.CheckersControlList.size(); i != e; ++i) {
131     const std::pair<std::string, bool> &opt = Opts.CheckersControlList[i];
132     if (opt.second)
133       Res.push_back("-analyzer-disable-checker");
134     else
135       Res.push_back("-analyzer-checker");
136     Res.push_back(opt.first);
137   }
138 }
139 
140 static void CodeGenOptsToArgs(const CodeGenOptions &Opts,
141                               std::vector<std::string> &Res) {
142   if (Opts.DebugInfo)
143     Res.push_back("-g");
144   if (Opts.DisableLLVMOpts)
145     Res.push_back("-disable-llvm-optzns");
146   if (Opts.DisableRedZone)
147     Res.push_back("-disable-red-zone");
148   if (!Opts.DebugCompilationDir.empty()) {
149     Res.push_back("-fdebug-compilation-dir");
150     Res.push_back(Opts.DebugCompilationDir);
151   }
152   if (!Opts.DwarfDebugFlags.empty()) {
153     Res.push_back("-dwarf-debug-flags");
154     Res.push_back(Opts.DwarfDebugFlags);
155   }
156   if (Opts.ObjCRuntimeHasARC)
157     Res.push_back("-fobjc-runtime-has-arc");
158   if (Opts.ObjCRuntimeHasTerminate)
159     Res.push_back("-fobjc-runtime-has-terminate");
160   if (Opts.EmitGcovArcs)
161     Res.push_back("-femit-coverage-data");
162   if (Opts.EmitGcovNotes)
163     Res.push_back("-femit-coverage-notes");
164   if (!Opts.MergeAllConstants)
165     Res.push_back("-fno-merge-all-constants");
166   if (Opts.NoCommon)
167     Res.push_back("-fno-common");
168   if (Opts.ForbidGuardVariables)
169     Res.push_back("-fforbid-guard-variables");
170   if (Opts.UseRegisterSizedBitfieldAccess)
171     Res.push_back("-fuse-register-sized-bitfield-access");
172   if (Opts.NoImplicitFloat)
173     Res.push_back("-no-implicit-float");
174   if (Opts.OmitLeafFramePointer)
175     Res.push_back("-momit-leaf-frame-pointer");
176   if (Opts.OptimizeSize) {
177     assert(Opts.OptimizationLevel == 2 && "Invalid options!");
178     Opts.OptimizeSize == 1 ? Res.push_back("-Os") : Res.push_back("-Oz");
179   } else if (Opts.OptimizationLevel != 0)
180     Res.push_back("-O" + llvm::utostr(Opts.OptimizationLevel));
181   if (!Opts.MainFileName.empty()) {
182     Res.push_back("-main-file-name");
183     Res.push_back(Opts.MainFileName);
184   }
185   // SimplifyLibCalls is only derived.
186   // TimePasses is only derived.
187   // UnitAtATime is unused.
188   // Inlining is only derived.
189 
190   // UnrollLoops is derived, but also accepts an option, no
191   // harm in pushing it back here.
192   if (Opts.UnrollLoops)
193     Res.push_back("-funroll-loops");
194   if (Opts.DataSections)
195     Res.push_back("-fdata-sections");
196   if (Opts.FunctionSections)
197     Res.push_back("-ffunction-sections");
198   if (Opts.AsmVerbose)
199     Res.push_back("-masm-verbose");
200   if (!Opts.CodeModel.empty()) {
201     Res.push_back("-mcode-model");
202     Res.push_back(Opts.CodeModel);
203   }
204   if (Opts.CUDAIsDevice)
205     Res.push_back("-fcuda-is-device");
206   if (!Opts.CXAAtExit)
207     Res.push_back("-fno-use-cxa-atexit");
208   if (Opts.CXXCtorDtorAliases)
209     Res.push_back("-mconstructor-aliases");
210   if (Opts.ObjCAutoRefCountExceptions)
211     Res.push_back("-fobjc-arc-eh");
212   if (!Opts.DebugPass.empty()) {
213     Res.push_back("-mdebug-pass");
214     Res.push_back(Opts.DebugPass);
215   }
216   if (Opts.DisableFPElim)
217     Res.push_back("-mdisable-fp-elim");
218   if (!Opts.FloatABI.empty()) {
219     Res.push_back("-mfloat-abi");
220     Res.push_back(Opts.FloatABI);
221   }
222   if (!Opts.LimitFloatPrecision.empty()) {
223     Res.push_back("-mlimit-float-precision");
224     Res.push_back(Opts.LimitFloatPrecision);
225   }
226   if (Opts.NoZeroInitializedInBSS)
227     Res.push_back("-mno-zero-initialized-bss");
228   switch (Opts.getObjCDispatchMethod()) {
229   case CodeGenOptions::Legacy:
230     break;
231   case CodeGenOptions::Mixed:
232     Res.push_back("-fobjc-dispatch-method=mixed");
233     break;
234   case CodeGenOptions::NonLegacy:
235     Res.push_back("-fobjc-dispatch-method=non-legacy");
236     break;
237   }
238   if (Opts.NumRegisterParameters) {
239     Res.push_back("-mregparm");
240     Res.push_back(llvm::utostr(Opts.NumRegisterParameters));
241   }
242   if (Opts.NoGlobalMerge)
243     Res.push_back("-mno-global-merge");
244   if (Opts.NoExecStack)
245     Res.push_back("-mnoexecstack");
246   if (Opts.RelaxAll)
247     Res.push_back("-mrelax-all");
248   if (Opts.SaveTempLabels)
249     Res.push_back("-msave-temp-labels");
250   if (Opts.NoDwarf2CFIAsm)
251     Res.push_back("-fno-dwarf2-cfi-asm");
252   if (Opts.NoDwarfDirectoryAsm)
253     Res.push_back("-fno-dwarf-directory-asm");
254   if (Opts.SoftFloat)
255     Res.push_back("-msoft-float");
256   if (Opts.UnwindTables)
257     Res.push_back("-munwind-tables");
258   if (Opts.RelocationModel != "pic") {
259     Res.push_back("-mrelocation-model");
260     Res.push_back(Opts.RelocationModel);
261   }
262   if (!Opts.VerifyModule)
263     Res.push_back("-disable-llvm-verifier");
264   for (unsigned i = 0, e = Opts.BackendOptions.size(); i != e; ++i) {
265     Res.push_back("-backend-option");
266     Res.push_back(Opts.BackendOptions[i]);
267   }
268 }
269 
270 static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts,
271                                        std::vector<std::string> &Res) {
272   if (Opts.IncludeSystemHeaders)
273     Res.push_back("-sys-header-deps");
274   if (Opts.ShowHeaderIncludes)
275     Res.push_back("-H");
276   if (!Opts.HeaderIncludeOutputFile.empty()) {
277     Res.push_back("-header-include-file");
278     Res.push_back(Opts.HeaderIncludeOutputFile);
279   }
280   if (Opts.UsePhonyTargets)
281     Res.push_back("-MP");
282   if (!Opts.OutputFile.empty()) {
283     Res.push_back("-dependency-file");
284     Res.push_back(Opts.OutputFile);
285   }
286   for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i) {
287     Res.push_back("-MT");
288     Res.push_back(Opts.Targets[i]);
289   }
290 }
291 
292 static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts,
293                                  std::vector<std::string> &Res) {
294   if (Opts.IgnoreWarnings)
295     Res.push_back("-w");
296   if (Opts.NoRewriteMacros)
297     Res.push_back("-Wno-rewrite-macros");
298   if (Opts.Pedantic)
299     Res.push_back("-pedantic");
300   if (Opts.PedanticErrors)
301     Res.push_back("-pedantic-errors");
302   if (!Opts.ShowColumn)
303     Res.push_back("-fno-show-column");
304   if (!Opts.ShowLocation)
305     Res.push_back("-fno-show-source-location");
306   if (!Opts.ShowCarets)
307     Res.push_back("-fno-caret-diagnostics");
308   if (!Opts.ShowFixits)
309     Res.push_back("-fno-diagnostics-fixit-info");
310   if (Opts.ShowSourceRanges)
311     Res.push_back("-fdiagnostics-print-source-range-info");
312   if (Opts.ShowParseableFixits)
313     Res.push_back("-fdiagnostics-parseable-fixits");
314   if (Opts.ShowColors)
315     Res.push_back("-fcolor-diagnostics");
316   if (Opts.VerifyDiagnostics)
317     Res.push_back("-verify");
318   if (Opts.ShowNames)
319     Res.push_back("-fdiagnostics-show-name");
320   if (Opts.ShowOptionNames)
321     Res.push_back("-fdiagnostics-show-option");
322   if (Opts.ShowCategories == 1)
323     Res.push_back("-fdiagnostics-show-category=id");
324   else if (Opts.ShowCategories == 2)
325     Res.push_back("-fdiagnostics-show-category=name");
326   switch (Opts.Format) {
327   case DiagnosticOptions::Clang:
328     Res.push_back("-fdiagnostics-format=clang"); break;
329   case DiagnosticOptions::Msvc:
330     Res.push_back("-fdiagnostics-format=msvc");  break;
331   case DiagnosticOptions::Vi:
332     Res.push_back("-fdiagnostics-format=vi");    break;
333   }
334   if (Opts.ErrorLimit) {
335     Res.push_back("-ferror-limit");
336     Res.push_back(llvm::utostr(Opts.ErrorLimit));
337   }
338   if (!Opts.DiagnosticLogFile.empty()) {
339     Res.push_back("-diagnostic-log-file");
340     Res.push_back(Opts.DiagnosticLogFile);
341   }
342   if (Opts.MacroBacktraceLimit
343                         != DiagnosticOptions::DefaultMacroBacktraceLimit) {
344     Res.push_back("-fmacro-backtrace-limit");
345     Res.push_back(llvm::utostr(Opts.MacroBacktraceLimit));
346   }
347   if (Opts.TemplateBacktraceLimit
348                         != DiagnosticOptions::DefaultTemplateBacktraceLimit) {
349     Res.push_back("-ftemplate-backtrace-limit");
350     Res.push_back(llvm::utostr(Opts.TemplateBacktraceLimit));
351   }
352 
353   if (Opts.TabStop != DiagnosticOptions::DefaultTabStop) {
354     Res.push_back("-ftabstop");
355     Res.push_back(llvm::utostr(Opts.TabStop));
356   }
357   if (Opts.MessageLength) {
358     Res.push_back("-fmessage-length");
359     Res.push_back(llvm::utostr(Opts.MessageLength));
360   }
361   if (!Opts.DumpBuildInformation.empty()) {
362     Res.push_back("-dump-build-information");
363     Res.push_back(Opts.DumpBuildInformation);
364   }
365   for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i)
366     Res.push_back("-W" + Opts.Warnings[i]);
367 }
368 
369 static const char *getInputKindName(InputKind Kind) {
370   switch (Kind) {
371   case IK_None:              break;
372   case IK_AST:               return "ast";
373   case IK_Asm:               return "assembler-with-cpp";
374   case IK_C:                 return "c";
375   case IK_CXX:               return "c++";
376   case IK_LLVM_IR:           return "ir";
377   case IK_ObjC:              return "objective-c";
378   case IK_ObjCXX:            return "objective-c++";
379   case IK_OpenCL:            return "cl";
380   case IK_CUDA:              return "cuda";
381   case IK_PreprocessedC:     return "cpp-output";
382   case IK_PreprocessedCXX:   return "c++-cpp-output";
383   case IK_PreprocessedObjC:  return "objective-c-cpp-output";
384   case IK_PreprocessedObjCXX:return "objective-c++-cpp-output";
385   }
386 
387   llvm_unreachable("Unexpected language kind!");
388   return 0;
389 }
390 
391 static const char *getActionName(frontend::ActionKind Kind) {
392   switch (Kind) {
393   case frontend::PluginAction:
394     llvm_unreachable("Invalid kind!");
395 
396   case frontend::ASTDump:                return "-ast-dump";
397   case frontend::ASTDumpXML:             return "-ast-dump-xml";
398   case frontend::ASTPrint:               return "-ast-print";
399   case frontend::ASTView:                return "-ast-view";
400   case frontend::DumpRawTokens:          return "-dump-raw-tokens";
401   case frontend::DumpTokens:             return "-dump-tokens";
402   case frontend::EmitAssembly:           return "-S";
403   case frontend::EmitBC:                 return "-emit-llvm-bc";
404   case frontend::EmitHTML:               return "-emit-html";
405   case frontend::EmitLLVM:               return "-emit-llvm";
406   case frontend::EmitLLVMOnly:           return "-emit-llvm-only";
407   case frontend::EmitCodeGenOnly:        return "-emit-codegen-only";
408   case frontend::EmitObj:                return "-emit-obj";
409   case frontend::FixIt:                  return "-fixit";
410   case frontend::GenerateModule:         return "-emit-module";
411   case frontend::GenerateModuleFromMap:  return "-emit-module-from-map";
412   case frontend::GeneratePCH:            return "-emit-pch";
413   case frontend::GeneratePTH:            return "-emit-pth";
414   case frontend::InitOnly:               return "-init-only";
415   case frontend::ParseSyntaxOnly:        return "-fsyntax-only";
416   case frontend::PrintDeclContext:       return "-print-decl-contexts";
417   case frontend::PrintPreamble:          return "-print-preamble";
418   case frontend::PrintPreprocessedInput: return "-E";
419   case frontend::RewriteMacros:          return "-rewrite-macros";
420   case frontend::RewriteObjC:            return "-rewrite-objc";
421   case frontend::RewriteTest:            return "-rewrite-test";
422   case frontend::RunAnalysis:            return "-analyze";
423   case frontend::RunPreprocessorOnly:    return "-Eonly";
424   }
425 
426   llvm_unreachable("Unexpected language kind!");
427   return 0;
428 }
429 
430 static void FileSystemOptsToArgs(const FileSystemOptions &Opts,
431                                  std::vector<std::string> &Res) {
432   if (!Opts.WorkingDir.empty()) {
433     Res.push_back("-working-directory");
434     Res.push_back(Opts.WorkingDir);
435   }
436 }
437 
438 static void FrontendOptsToArgs(const FrontendOptions &Opts,
439                                std::vector<std::string> &Res) {
440   if (Opts.DisableFree)
441     Res.push_back("-disable-free");
442   if (Opts.RelocatablePCH)
443     Res.push_back("-relocatable-pch");
444   if (Opts.ShowHelp)
445     Res.push_back("-help");
446   if (Opts.ShowMacrosInCodeCompletion)
447     Res.push_back("-code-completion-macros");
448   if (Opts.ShowCodePatternsInCodeCompletion)
449     Res.push_back("-code-completion-patterns");
450   if (!Opts.ShowGlobalSymbolsInCodeCompletion)
451     Res.push_back("-no-code-completion-globals");
452   if (Opts.ShowStats)
453     Res.push_back("-print-stats");
454   if (Opts.ShowTimers)
455     Res.push_back("-ftime-report");
456   if (Opts.ShowVersion)
457     Res.push_back("-version");
458   if (Opts.FixWhatYouCan)
459     Res.push_back("-fix-what-you-can");
460   switch (Opts.ARCMTAction) {
461   case FrontendOptions::ARCMT_None:
462     break;
463   case FrontendOptions::ARCMT_Check:
464     Res.push_back("-arcmt-check");
465     break;
466   case FrontendOptions::ARCMT_Modify:
467     Res.push_back("-arcmt-modify");
468     break;
469   case FrontendOptions::ARCMT_Migrate:
470     Res.push_back("-arcmt-migrate");
471     break;
472   }
473   if (!Opts.ARCMTMigrateDir.empty()) {
474     Res.push_back("-arcmt-migrate-directory");
475     Res.push_back(Opts.ARCMTMigrateDir);
476   }
477   if (!Opts.ARCMTMigrateReportOut.empty()) {
478     Res.push_back("-arcmt-migrate-report-output");
479     Res.push_back(Opts.ARCMTMigrateReportOut);
480   }
481   if (Opts.ARCMTMigrateEmitARCErrors)
482     Res.push_back("-arcmt-migrate-emit-errors");
483 
484   bool NeedLang = false;
485   for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i)
486     if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].second) !=
487         Opts.Inputs[i].first)
488       NeedLang = true;
489   if (NeedLang) {
490     Res.push_back("-x");
491     Res.push_back(getInputKindName(Opts.Inputs[0].first));
492   }
493   for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) {
494     assert((!NeedLang || Opts.Inputs[i].first == Opts.Inputs[0].first) &&
495            "Unable to represent this input vector!");
496     Res.push_back(Opts.Inputs[i].second);
497   }
498 
499   if (!Opts.OutputFile.empty()) {
500     Res.push_back("-o");
501     Res.push_back(Opts.OutputFile);
502   }
503   if (!Opts.CodeCompletionAt.FileName.empty()) {
504     Res.push_back("-code-completion-at");
505     Res.push_back(Opts.CodeCompletionAt.FileName + ":" +
506                   llvm::utostr(Opts.CodeCompletionAt.Line) + ":" +
507                   llvm::utostr(Opts.CodeCompletionAt.Column));
508   }
509   if (Opts.ProgramAction != frontend::PluginAction)
510     Res.push_back(getActionName(Opts.ProgramAction));
511   if (!Opts.ActionName.empty()) {
512     Res.push_back("-plugin");
513     Res.push_back(Opts.ActionName);
514     for(unsigned i = 0, e = Opts.PluginArgs.size(); i != e; ++i) {
515       Res.push_back("-plugin-arg-" + Opts.ActionName);
516       Res.push_back(Opts.PluginArgs[i]);
517     }
518   }
519   for (unsigned i = 0, e = Opts.Plugins.size(); i != e; ++i) {
520     Res.push_back("-load");
521     Res.push_back(Opts.Plugins[i]);
522   }
523   for (unsigned i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
524     Res.push_back("-add-plugin");
525     Res.push_back(Opts.AddPluginActions[i]);
526     for(unsigned ai = 0, ae = Opts.AddPluginArgs.size(); ai != ae; ++ai) {
527       Res.push_back("-plugin-arg-" + Opts.AddPluginActions[i]);
528       Res.push_back(Opts.AddPluginArgs[i][ai]);
529     }
530   }
531   for (unsigned i = 0, e = Opts.ASTMergeFiles.size(); i != e; ++i) {
532     Res.push_back("-ast-merge");
533     Res.push_back(Opts.ASTMergeFiles[i]);
534   }
535   for (unsigned i = 0, e = Opts.LLVMArgs.size(); i != e; ++i) {
536     Res.push_back("-mllvm");
537     Res.push_back(Opts.LLVMArgs[i]);
538   }
539 }
540 
541 static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts,
542                                    std::vector<std::string> &Res) {
543   if (Opts.Sysroot != "/") {
544     Res.push_back("-isysroot");
545     Res.push_back(Opts.Sysroot);
546   }
547 
548   /// User specified include entries.
549   for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) {
550     const HeaderSearchOptions::Entry &E = Opts.UserEntries[i];
551     if (E.IsFramework && (E.Group != frontend::Angled || !E.IsUserSupplied))
552       llvm::report_fatal_error("Invalid option set!");
553     if (E.IsUserSupplied) {
554       switch (E.Group) {
555       case frontend::After:
556         Res.push_back("-idirafter");
557         break;
558 
559       case frontend::Quoted:
560         Res.push_back("-iquote");
561         break;
562 
563       case frontend::System:
564         Res.push_back("-isystem");
565         break;
566 
567       case frontend::IndexHeaderMap:
568         Res.push_back("-index-header-map");
569         Res.push_back(E.IsFramework? "-F" : "-I");
570         break;
571 
572       case frontend::CSystem:
573         Res.push_back("-c-isystem");
574         break;
575 
576       case frontend::CXXSystem:
577         Res.push_back("-cxx-isystem");
578         break;
579 
580       case frontend::ObjCSystem:
581         Res.push_back("-objc-isystem");
582         break;
583 
584       case frontend::ObjCXXSystem:
585         Res.push_back("-objcxx-isystem");
586         break;
587 
588       case frontend::Angled:
589         Res.push_back(E.IsFramework ? "-F" : "-I");
590         break;
591       }
592     } else {
593       if (E.IsInternal) {
594         assert(E.Group == frontend::System && "Unexpected header search group");
595         if (E.ImplicitExternC)
596           Res.push_back("-internal-externc-isystem");
597         else
598           Res.push_back("-internal-isystem");
599       } else {
600         if (E.Group != frontend::Angled && E.Group != frontend::System)
601           llvm::report_fatal_error("Invalid option set!");
602         Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
603                       "-iwithprefix");
604       }
605     }
606     Res.push_back(E.Path);
607   }
608 
609   if (!Opts.ResourceDir.empty()) {
610     Res.push_back("-resource-dir");
611     Res.push_back(Opts.ResourceDir);
612   }
613   if (!Opts.ModuleCachePath.empty()) {
614     Res.push_back("-fmodule-cache-path");
615     Res.push_back(Opts.ModuleCachePath);
616   }
617   if (!Opts.UseStandardSystemIncludes)
618     Res.push_back("-nostdsysteminc");
619   if (!Opts.UseStandardCXXIncludes)
620     Res.push_back("-nostdinc++");
621   if (Opts.UseLibcxx)
622     Res.push_back("-stdlib=libc++");
623   if (Opts.Verbose)
624     Res.push_back("-v");
625 }
626 
627 static void LangOptsToArgs(const LangOptions &Opts,
628                            std::vector<std::string> &Res) {
629   LangOptions DefaultLangOpts;
630 
631   // FIXME: Need to set -std to get all the implicit options.
632 
633   // FIXME: We want to only pass options relative to the defaults, which
634   // requires constructing a target. :(
635   //
636   // It would be better to push the all target specific choices into the driver,
637   // so that everything below that was more uniform.
638 
639   if (Opts.Trigraphs)
640     Res.push_back("-trigraphs");
641   // Implicit based on the input kind:
642   //   AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
643   // Implicit based on the input language standard:
644   //   BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
645   if (Opts.DollarIdents)
646     Res.push_back("-fdollars-in-identifiers");
647   if (Opts.GNUMode && !Opts.GNUKeywords)
648     Res.push_back("-fno-gnu-keywords");
649   if (!Opts.GNUMode && Opts.GNUKeywords)
650     Res.push_back("-fgnu-keywords");
651   if (Opts.MicrosoftExt)
652     Res.push_back("-fms-extensions");
653   if (Opts.MicrosoftMode)
654     Res.push_back("-fms-compatibility");
655   if (Opts.MSCVersion != 0)
656     Res.push_back("-fmsc-version=" + llvm::utostr(Opts.MSCVersion));
657   if (Opts.Borland)
658     Res.push_back("-fborland-extensions");
659   if (!Opts.ObjCNonFragileABI)
660     Res.push_back("-fobjc-fragile-abi");
661   if (Opts.ObjCDefaultSynthProperties)
662     Res.push_back("-fobjc-default-synthesize-properties");
663   // NoInline is implicit.
664   if (!Opts.CXXOperatorNames)
665     Res.push_back("-fno-operator-names");
666   if (Opts.PascalStrings)
667     Res.push_back("-fpascal-strings");
668   if (Opts.CatchUndefined)
669     Res.push_back("-fcatch-undefined-behavior");
670   if (Opts.AddressSanitizer)
671     Res.push_back("-faddress-sanitizer");
672   if (Opts.WritableStrings)
673     Res.push_back("-fwritable-strings");
674   if (Opts.ConstStrings)
675     Res.push_back("-fconst-strings");
676   if (!Opts.LaxVectorConversions)
677     Res.push_back("-fno-lax-vector-conversions");
678   if (Opts.AltiVec)
679     Res.push_back("-faltivec");
680   if (Opts.Exceptions)
681     Res.push_back("-fexceptions");
682   if (Opts.ObjCExceptions)
683     Res.push_back("-fobjc-exceptions");
684   if (Opts.CXXExceptions)
685     Res.push_back("-fcxx-exceptions");
686   if (Opts.SjLjExceptions)
687     Res.push_back("-fsjlj-exceptions");
688   if (Opts.TraditionalCPP)
689     Res.push_back("-traditional-cpp");
690   if (!Opts.RTTI)
691     Res.push_back("-fno-rtti");
692   if (Opts.MSBitfields)
693     Res.push_back("-mms-bitfields");
694   if (!Opts.NeXTRuntime)
695     Res.push_back("-fgnu-runtime");
696   if (Opts.Freestanding)
697     Res.push_back("-ffreestanding");
698   if (Opts.NoBuiltin)
699     Res.push_back("-fno-builtin");
700   if (!Opts.AssumeSaneOperatorNew)
701     Res.push_back("-fno-assume-sane-operator-new");
702   if (!Opts.ThreadsafeStatics)
703     Res.push_back("-fno-threadsafe-statics");
704   if (Opts.POSIXThreads)
705     Res.push_back("-pthread");
706   if (Opts.Blocks)
707     Res.push_back("-fblocks");
708   if (Opts.BlocksRuntimeOptional)
709     Res.push_back("-fblocks-runtime-optional");
710   if (Opts.EmitAllDecls)
711     Res.push_back("-femit-all-decls");
712   if (Opts.MathErrno)
713     Res.push_back("-fmath-errno");
714   switch (Opts.getSignedOverflowBehavior()) {
715   case LangOptions::SOB_Undefined: break;
716   case LangOptions::SOB_Defined:   Res.push_back("-fwrapv"); break;
717   case LangOptions::SOB_Trapping:
718     Res.push_back("-ftrapv");
719     if (!Opts.OverflowHandler.empty()) {
720       Res.push_back("-ftrapv-handler");
721       Res.push_back(Opts.OverflowHandler);
722     }
723     break;
724   }
725   if (Opts.HeinousExtensions)
726     Res.push_back("-fheinous-gnu-extensions");
727   // Optimize is implicit.
728   // OptimizeSize is implicit.
729   if (Opts.Static)
730     Res.push_back("-static-define");
731   if (Opts.DumpRecordLayouts)
732     Res.push_back("-fdump-record-layouts");
733   if (Opts.DumpVTableLayouts)
734     Res.push_back("-fdump-vtable-layouts");
735   if (Opts.NoBitFieldTypeAlign)
736     Res.push_back("-fno-bitfield-type-alignment");
737   if (Opts.PICLevel) {
738     Res.push_back("-pic-level");
739     Res.push_back(llvm::utostr(Opts.PICLevel));
740   }
741   if (Opts.ObjCGCBitmapPrint)
742     Res.push_back("-print-ivar-layout");
743   if (Opts.NoConstantCFStrings)
744     Res.push_back("-fno-constant-cfstrings");
745   if (!Opts.AccessControl)
746     Res.push_back("-fno-access-control");
747   if (!Opts.CharIsSigned)
748     Res.push_back("-fno-signed-char");
749   if (Opts.ShortWChar)
750     Res.push_back("-fshort-wchar");
751   if (!Opts.ElideConstructors)
752     Res.push_back("-fno-elide-constructors");
753   if (Opts.getGC() != LangOptions::NonGC) {
754     if (Opts.getGC() == LangOptions::HybridGC) {
755       Res.push_back("-fobjc-gc");
756     } else {
757       assert(Opts.getGC() == LangOptions::GCOnly && "Invalid GC mode!");
758       Res.push_back("-fobjc-gc-only");
759     }
760   }
761   if (Opts.ObjCAutoRefCount)
762     Res.push_back("-fobjc-arc");
763   if (Opts.ObjCRuntimeHasWeak)
764     Res.push_back("-fobjc-runtime-has-weak");
765   if (!Opts.ObjCInferRelatedResultType)
766     Res.push_back("-fno-objc-infer-related-result-type");
767 
768   if (Opts.AppleKext)
769     Res.push_back("-fapple-kext");
770 
771   if (Opts.getVisibilityMode() != DefaultVisibility) {
772     Res.push_back("-fvisibility");
773     if (Opts.getVisibilityMode() == HiddenVisibility) {
774       Res.push_back("hidden");
775     } else {
776       assert(Opts.getVisibilityMode() == ProtectedVisibility &&
777              "Invalid visibility!");
778       Res.push_back("protected");
779     }
780   }
781   if (Opts.InlineVisibilityHidden)
782     Res.push_back("-fvisibility-inlines-hidden");
783 
784   if (Opts.getStackProtector() != 0) {
785     Res.push_back("-stack-protector");
786     Res.push_back(llvm::utostr(Opts.getStackProtector()));
787   }
788   if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) {
789     Res.push_back("-ftemplate-depth");
790     Res.push_back(llvm::utostr(Opts.InstantiationDepth));
791   }
792   if (Opts.ConstexprCallDepth != DefaultLangOpts.ConstexprCallDepth) {
793     Res.push_back("-fconstexpr-depth");
794     Res.push_back(llvm::utostr(Opts.ConstexprCallDepth));
795   }
796   if (!Opts.ObjCConstantStringClass.empty()) {
797     Res.push_back("-fconstant-string-class");
798     Res.push_back(Opts.ObjCConstantStringClass);
799   }
800   if (Opts.FakeAddressSpaceMap)
801     Res.push_back("-ffake-address-space-map");
802   if (Opts.ParseUnknownAnytype)
803     Res.push_back("-funknown-anytype");
804   if (Opts.DebuggerSupport)
805     Res.push_back("-fdebugger-support");
806   if (Opts.DelayedTemplateParsing)
807     Res.push_back("-fdelayed-template-parsing");
808   if (Opts.Deprecated)
809     Res.push_back("-fdeprecated-macro");
810   if (Opts.ApplePragmaPack)
811     Res.push_back("-fapple-pragma-pack");
812   if (!Opts.CurrentModule.empty())
813     Res.push_back("-fmodule-name=" + Opts.CurrentModule);
814 }
815 
816 static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
817                                    std::vector<std::string> &Res) {
818   for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
819     Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") +
820                   Opts.Macros[i].first);
821   for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
822     // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
823     Res.push_back("-include");
824     Res.push_back(Opts.Includes[i]);
825   }
826   for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) {
827     Res.push_back("-imacros");
828     Res.push_back(Opts.MacroIncludes[i]);
829   }
830   if (!Opts.UsePredefines)
831     Res.push_back("-undef");
832   if (Opts.DetailedRecord)
833     Res.push_back("-detailed-preprocessing-record");
834   if (!Opts.ImplicitPCHInclude.empty()) {
835     Res.push_back("-include-pch");
836     Res.push_back(Opts.ImplicitPCHInclude);
837   }
838   if (!Opts.ImplicitPTHInclude.empty()) {
839     Res.push_back("-include-pth");
840     Res.push_back(Opts.ImplicitPTHInclude);
841   }
842   if (!Opts.TokenCache.empty()) {
843     if (Opts.ImplicitPTHInclude.empty()) {
844       Res.push_back("-token-cache");
845       Res.push_back(Opts.TokenCache);
846     } else
847       assert(Opts.ImplicitPTHInclude == Opts.TokenCache &&
848              "Unsupported option combination!");
849   }
850   for (unsigned i = 0, e = Opts.ChainedIncludes.size(); i != e; ++i) {
851     Res.push_back("-chain-include");
852     Res.push_back(Opts.ChainedIncludes[i]);
853   }
854   for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) {
855     Res.push_back("-remap-file");
856     Res.push_back(Opts.RemappedFiles[i].first + ";" +
857                   Opts.RemappedFiles[i].second);
858   }
859 }
860 
861 static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
862                                          std::vector<std::string> &Res) {
863   if (!Opts.ShowCPP && !Opts.ShowMacros)
864     llvm::report_fatal_error("Invalid option combination!");
865 
866   if (Opts.ShowCPP && Opts.ShowMacros)
867     Res.push_back("-dD");
868   else if (!Opts.ShowCPP && Opts.ShowMacros)
869     Res.push_back("-dM");
870 
871   if (!Opts.ShowLineMarkers)
872     Res.push_back("-P");
873   if (Opts.ShowComments)
874     Res.push_back("-C");
875   if (Opts.ShowMacroComments)
876     Res.push_back("-CC");
877 }
878 
879 static void TargetOptsToArgs(const TargetOptions &Opts,
880                              std::vector<std::string> &Res) {
881   Res.push_back("-triple");
882   Res.push_back(Opts.Triple);
883   if (!Opts.CPU.empty()) {
884     Res.push_back("-target-cpu");
885     Res.push_back(Opts.CPU);
886   }
887   if (!Opts.ABI.empty()) {
888     Res.push_back("-target-abi");
889     Res.push_back(Opts.ABI);
890   }
891   if (!Opts.LinkerVersion.empty()) {
892     Res.push_back("-target-linker-version");
893     Res.push_back(Opts.LinkerVersion);
894   }
895   if (!Opts.CXXABI.empty()) {
896     Res.push_back("-cxx-abi");
897     Res.push_back(Opts.CXXABI);
898   }
899   for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) {
900     Res.push_back("-target-feature");
901     Res.push_back(Opts.Features[i]);
902   }
903 }
904 
905 void CompilerInvocation::toArgs(std::vector<std::string> &Res) {
906   AnalyzerOptsToArgs(getAnalyzerOpts(), Res);
907   CodeGenOptsToArgs(getCodeGenOpts(), Res);
908   DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res);
909   DiagnosticOptsToArgs(getDiagnosticOpts(), Res);
910   FileSystemOptsToArgs(getFileSystemOpts(), Res);
911   FrontendOptsToArgs(getFrontendOpts(), Res);
912   HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res);
913   LangOptsToArgs(*getLangOpts(), Res);
914   PreprocessorOptsToArgs(getPreprocessorOpts(), Res);
915   PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res);
916   TargetOptsToArgs(getTargetOpts(), Res);
917 }
918 
919 //===----------------------------------------------------------------------===//
920 // Deserialization (to args)
921 //===----------------------------------------------------------------------===//
922 
923 using namespace clang::driver;
924 using namespace clang::driver::cc1options;
925 
926 //
927 
928 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
929                                      DiagnosticsEngine &Diags) {
930   unsigned DefaultOpt = 0;
931   if (IK == IK_OpenCL && !Args.hasArg(OPT_cl_opt_disable))
932     DefaultOpt = 2;
933   // -Os/-Oz implies -O2
934   return (Args.hasArg(OPT_Os) || Args.hasArg (OPT_Oz)) ? 2 :
935     Args.getLastArgIntValue(OPT_O, DefaultOpt, Diags);
936 }
937 
938 static void ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
939                               DiagnosticsEngine &Diags) {
940   using namespace cc1options;
941 
942   if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
943     StringRef Name = A->getValue(Args);
944     AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
945 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
946       .Case(CMDFLAG, NAME##Model)
947 #include "clang/Frontend/Analyses.def"
948       .Default(NumStores);
949     // FIXME: Error handling.
950     if (Value == NumStores)
951       Diags.Report(diag::err_drv_invalid_value)
952         << A->getAsString(Args) << Name;
953     else
954       Opts.AnalysisStoreOpt = Value;
955   }
956 
957   if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
958     StringRef Name = A->getValue(Args);
959     AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
960 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
961       .Case(CMDFLAG, NAME##Model)
962 #include "clang/Frontend/Analyses.def"
963       .Default(NumConstraints);
964     // FIXME: Error handling.
965     if (Value == NumConstraints)
966       Diags.Report(diag::err_drv_invalid_value)
967         << A->getAsString(Args) << Name;
968     else
969       Opts.AnalysisConstraintsOpt = Value;
970   }
971 
972   if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
973     StringRef Name = A->getValue(Args);
974     AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
975 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
976       .Case(CMDFLAG, PD_##NAME)
977 #include "clang/Frontend/Analyses.def"
978       .Default(NUM_ANALYSIS_DIAG_CLIENTS);
979     // FIXME: Error handling.
980     if (Value == NUM_ANALYSIS_DIAG_CLIENTS)
981       Diags.Report(diag::err_drv_invalid_value)
982         << A->getAsString(Args) << Name;
983     else
984       Opts.AnalysisDiagOpt = Value;
985   }
986 
987   if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
988     StringRef Name = A->getValue(Args);
989     AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
990 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
991       .Case(CMDFLAG, NAME)
992 #include "clang/Frontend/Analyses.def"
993       .Default(NumPurgeModes);
994     // FIXME: Error handling.
995     if (Value == NumPurgeModes)
996       Diags.Report(diag::err_drv_invalid_value)
997         << A->getAsString(Args) << Name;
998     else
999       Opts.AnalysisPurgeOpt = Value;
1000   }
1001 
1002   Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
1003   Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
1004   Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
1005   Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
1006   Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
1007   Opts.AnalyzeNestedBlocks =
1008     Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
1009   Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume);
1010   Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
1011   Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
1012   Opts.CFGAddImplicitDtors = Args.hasArg(OPT_analysis_CFGAddImplicitDtors);
1013   Opts.CFGAddInitializers = Args.hasArg(OPT_analysis_CFGAddInitializers);
1014   Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
1015   Opts.MaxNodes = Args.getLastArgIntValue(OPT_analyzer_max_nodes, 150000,Diags);
1016   Opts.MaxLoop = Args.getLastArgIntValue(OPT_analyzer_max_loop, 4, Diags);
1017   Opts.EagerlyTrimEGraph = !Args.hasArg(OPT_analyzer_no_eagerly_trim_egraph);
1018   Opts.InlineCall = Args.hasArg(OPT_analyzer_inline_call);
1019 
1020   Opts.CheckersControlList.clear();
1021   for (arg_iterator it = Args.filtered_begin(OPT_analyzer_checker,
1022                                              OPT_analyzer_disable_checker),
1023          ie = Args.filtered_end(); it != ie; ++it) {
1024     const Arg *A = *it;
1025     A->claim();
1026     bool enable = (A->getOption().getID() == OPT_analyzer_checker);
1027     // We can have a list of comma separated checker names, e.g:
1028     // '-analyzer-checker=cocoa,unix'
1029     StringRef checkerList = A->getValue(Args);
1030     SmallVector<StringRef, 4> checkers;
1031     checkerList.split(checkers, ",");
1032     for (unsigned i = 0, e = checkers.size(); i != e; ++i)
1033       Opts.CheckersControlList.push_back(std::make_pair(checkers[i], enable));
1034   }
1035 }
1036 
1037 static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
1038                              DiagnosticsEngine &Diags) {
1039   using namespace cc1options;
1040 
1041   Opts.OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
1042   if (Opts.OptimizationLevel > 3) {
1043     Diags.Report(diag::err_drv_invalid_value)
1044       << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel;
1045     Opts.OptimizationLevel = 3;
1046   }
1047 
1048   // We must always run at least the always inlining pass.
1049   Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining
1050     : CodeGenOptions::OnlyAlwaysInlining;
1051 
1052   Opts.DebugInfo = Args.hasArg(OPT_g);
1053   Opts.LimitDebugInfo = !Args.hasArg(OPT_fno_limit_debug_info)
1054     || Args.hasArg(OPT_flimit_debug_info);
1055   Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
1056   Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
1057   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
1058   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
1059     OPT_fuse_register_sized_bitfield_access);
1060   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
1061   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
1062   Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
1063   Opts.NoCommon = Args.hasArg(OPT_fno_common);
1064   Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
1065   Opts.OptimizeSize = Args.hasArg(OPT_Os);
1066   Opts.OptimizeSize = Args.hasArg(OPT_Oz) ? 2 : Opts.OptimizeSize;
1067   Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
1068                             Args.hasArg(OPT_ffreestanding));
1069   Opts.UnrollLoops = Args.hasArg(OPT_funroll_loops) ||
1070                      (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize);
1071 
1072   Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
1073   Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
1074   Opts.ObjCRuntimeHasARC = Args.hasArg(OPT_fobjc_runtime_has_arc);
1075   Opts.ObjCRuntimeHasTerminate = Args.hasArg(OPT_fobjc_runtime_has_terminate);
1076   Opts.CUDAIsDevice = Args.hasArg(OPT_fcuda_is_device);
1077   Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
1078   Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
1079   Opts.CodeModel = Args.getLastArgValue(OPT_mcode_model);
1080   Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
1081   Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim);
1082   Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
1083   Opts.HiddenWeakVTables = Args.hasArg(OPT_fhidden_weak_vtables);
1084   Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable);
1085   Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
1086   Opts.NoInfsFPMath = Opts.NoNaNsFPMath = Args.hasArg(OPT_cl_finite_math_only)||
1087                                           Args.hasArg(OPT_cl_fast_relaxed_math);
1088   Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
1089   Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
1090   Opts.NumRegisterParameters = Args.getLastArgIntValue(OPT_mregparm, 0, Diags);
1091   Opts.NoGlobalMerge = Args.hasArg(OPT_mno_global_merge);
1092   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
1093   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
1094   Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
1095   Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
1096   Opts.NoDwarf2CFIAsm = Args.hasArg(OPT_fno_dwarf2_cfi_asm);
1097   Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
1098   Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
1099   Opts.UnsafeFPMath = Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
1100                       Args.hasArg(OPT_cl_fast_relaxed_math);
1101   Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
1102   Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
1103 
1104   Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections);
1105   Opts.DataSections = Args.hasArg(OPT_fdata_sections);
1106 
1107   Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
1108   Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
1109 
1110   Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
1111   Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
1112   Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
1113   Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
1114   Opts.CoverageFile = Args.getLastArgValue(OPT_coverage_file);
1115   Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
1116   Opts.LinkBitcodeFile = Args.getLastArgValue(OPT_mlink_bitcode_file);
1117 
1118   if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
1119     StringRef Name = A->getValue(Args);
1120     unsigned Method = llvm::StringSwitch<unsigned>(Name)
1121       .Case("legacy", CodeGenOptions::Legacy)
1122       .Case("non-legacy", CodeGenOptions::NonLegacy)
1123       .Case("mixed", CodeGenOptions::Mixed)
1124       .Default(~0U);
1125     if (Method == ~0U)
1126       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1127     else
1128       Opts.ObjCDispatchMethod = Method;
1129   }
1130 }
1131 
1132 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
1133                                       ArgList &Args) {
1134   using namespace cc1options;
1135   Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
1136   Opts.Targets = Args.getAllArgValues(OPT_MT);
1137   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
1138   Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
1139   Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
1140   Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
1141   Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
1142 }
1143 
1144 static void ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
1145                                 DiagnosticsEngine &Diags) {
1146   using namespace cc1options;
1147   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
1148   Opts.DiagnosticSerializationFile =
1149     Args.getLastArgValue(OPT_diagnostic_serialized_file);
1150   Opts.IgnoreWarnings = Args.hasArg(OPT_w);
1151   Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
1152   Opts.Pedantic = Args.hasArg(OPT_pedantic);
1153   Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
1154   Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
1155   Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics);
1156   Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
1157                                  OPT_fno_show_column,
1158                                  /*Default=*/true);
1159   Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
1160   Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
1161   Opts.ShowNames = Args.hasArg(OPT_fdiagnostics_show_name);
1162   Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
1163 
1164   // Default behavior is to not to show note include stacks.
1165   Opts.ShowNoteIncludeStack = false;
1166   if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1167                                OPT_fno_diagnostics_show_note_include_stack))
1168     if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1169       Opts.ShowNoteIncludeStack = true;
1170 
1171   StringRef ShowOverloads =
1172     Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1173   if (ShowOverloads == "best")
1174     Opts.ShowOverloads = DiagnosticsEngine::Ovl_Best;
1175   else if (ShowOverloads == "all")
1176     Opts.ShowOverloads = DiagnosticsEngine::Ovl_All;
1177   else
1178     Diags.Report(diag::err_drv_invalid_value)
1179       << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1180       << ShowOverloads;
1181 
1182   StringRef ShowCategory =
1183     Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
1184   if (ShowCategory == "none")
1185     Opts.ShowCategories = 0;
1186   else if (ShowCategory == "id")
1187     Opts.ShowCategories = 1;
1188   else if (ShowCategory == "name")
1189     Opts.ShowCategories = 2;
1190   else
1191     Diags.Report(diag::err_drv_invalid_value)
1192       << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1193       << ShowCategory;
1194 
1195   StringRef Format =
1196     Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1197   if (Format == "clang")
1198     Opts.Format = DiagnosticOptions::Clang;
1199   else if (Format == "msvc")
1200     Opts.Format = DiagnosticOptions::Msvc;
1201   else if (Format == "vi")
1202     Opts.Format = DiagnosticOptions::Vi;
1203   else
1204     Diags.Report(diag::err_drv_invalid_value)
1205       << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1206       << Format;
1207 
1208   Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
1209   Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
1210   Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
1211   Opts.ErrorLimit = Args.getLastArgIntValue(OPT_ferror_limit, 0, Diags);
1212   Opts.MacroBacktraceLimit
1213     = Args.getLastArgIntValue(OPT_fmacro_backtrace_limit,
1214                          DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
1215   Opts.TemplateBacktraceLimit
1216     = Args.getLastArgIntValue(OPT_ftemplate_backtrace_limit,
1217                          DiagnosticOptions::DefaultTemplateBacktraceLimit,
1218                          Diags);
1219   Opts.TabStop = Args.getLastArgIntValue(OPT_ftabstop,
1220                                     DiagnosticOptions::DefaultTabStop, Diags);
1221   if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1222     Diags.Report(diag::warn_ignoring_ftabstop_value)
1223       << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1224     Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1225   }
1226   Opts.MessageLength = Args.getLastArgIntValue(OPT_fmessage_length, 0, Diags);
1227   Opts.DumpBuildInformation = Args.getLastArgValue(OPT_dump_build_information);
1228   Opts.Warnings = Args.getAllArgValues(OPT_W);
1229 }
1230 
1231 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1232   Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1233 }
1234 
1235 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1236                                    DiagnosticsEngine &Diags) {
1237   using namespace cc1options;
1238   Opts.ProgramAction = frontend::ParseSyntaxOnly;
1239   if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1240     switch (A->getOption().getID()) {
1241     default:
1242       llvm_unreachable("Invalid option in group!");
1243     case OPT_ast_dump:
1244       Opts.ProgramAction = frontend::ASTDump; break;
1245     case OPT_ast_dump_xml:
1246       Opts.ProgramAction = frontend::ASTDumpXML; break;
1247     case OPT_ast_print:
1248       Opts.ProgramAction = frontend::ASTPrint; break;
1249     case OPT_ast_view:
1250       Opts.ProgramAction = frontend::ASTView; break;
1251     case OPT_dump_raw_tokens:
1252       Opts.ProgramAction = frontend::DumpRawTokens; break;
1253     case OPT_dump_tokens:
1254       Opts.ProgramAction = frontend::DumpTokens; break;
1255     case OPT_S:
1256       Opts.ProgramAction = frontend::EmitAssembly; break;
1257     case OPT_emit_llvm_bc:
1258       Opts.ProgramAction = frontend::EmitBC; break;
1259     case OPT_emit_html:
1260       Opts.ProgramAction = frontend::EmitHTML; break;
1261     case OPT_emit_llvm:
1262       Opts.ProgramAction = frontend::EmitLLVM; break;
1263     case OPT_emit_llvm_only:
1264       Opts.ProgramAction = frontend::EmitLLVMOnly; break;
1265     case OPT_emit_codegen_only:
1266       Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
1267     case OPT_emit_obj:
1268       Opts.ProgramAction = frontend::EmitObj; break;
1269     case OPT_fixit_EQ:
1270       Opts.FixItSuffix = A->getValue(Args);
1271       // fall-through!
1272     case OPT_fixit:
1273       Opts.ProgramAction = frontend::FixIt; break;
1274     case OPT_emit_module:
1275       Opts.ProgramAction = frontend::GenerateModule; break;
1276     case OPT_emit_module_from_map:
1277       Opts.ProgramAction = frontend::GenerateModuleFromMap; break;
1278     case OPT_emit_pch:
1279       Opts.ProgramAction = frontend::GeneratePCH; break;
1280     case OPT_emit_pth:
1281       Opts.ProgramAction = frontend::GeneratePTH; break;
1282     case OPT_init_only:
1283       Opts.ProgramAction = frontend::InitOnly; break;
1284     case OPT_fsyntax_only:
1285       Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
1286     case OPT_print_decl_contexts:
1287       Opts.ProgramAction = frontend::PrintDeclContext; break;
1288     case OPT_print_preamble:
1289       Opts.ProgramAction = frontend::PrintPreamble; break;
1290     case OPT_E:
1291       Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
1292     case OPT_rewrite_macros:
1293       Opts.ProgramAction = frontend::RewriteMacros; break;
1294     case OPT_rewrite_objc:
1295       Opts.ProgramAction = frontend::RewriteObjC; break;
1296     case OPT_rewrite_test:
1297       Opts.ProgramAction = frontend::RewriteTest; break;
1298     case OPT_analyze:
1299       Opts.ProgramAction = frontend::RunAnalysis; break;
1300     case OPT_Eonly:
1301       Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
1302     }
1303   }
1304 
1305   if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1306     Opts.Plugins.push_back(A->getValue(Args,0));
1307     Opts.ProgramAction = frontend::PluginAction;
1308     Opts.ActionName = A->getValue(Args);
1309 
1310     for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
1311            end = Args.filtered_end(); it != end; ++it) {
1312       if ((*it)->getValue(Args, 0) == Opts.ActionName)
1313         Opts.PluginArgs.push_back((*it)->getValue(Args, 1));
1314     }
1315   }
1316 
1317   Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
1318   Opts.AddPluginArgs.resize(Opts.AddPluginActions.size());
1319   for (int i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
1320     for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
1321            end = Args.filtered_end(); it != end; ++it) {
1322       if ((*it)->getValue(Args, 0) == Opts.AddPluginActions[i])
1323         Opts.AddPluginArgs[i].push_back((*it)->getValue(Args, 1));
1324     }
1325   }
1326 
1327   if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1328     Opts.CodeCompletionAt =
1329       ParsedSourceLocation::FromString(A->getValue(Args));
1330     if (Opts.CodeCompletionAt.FileName.empty())
1331       Diags.Report(diag::err_drv_invalid_value)
1332         << A->getAsString(Args) << A->getValue(Args);
1333   }
1334   Opts.DisableFree = Args.hasArg(OPT_disable_free);
1335 
1336   Opts.OutputFile = Args.getLastArgValue(OPT_o);
1337   Opts.Plugins = Args.getAllArgValues(OPT_load);
1338   Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
1339   Opts.ShowHelp = Args.hasArg(OPT_help);
1340   Opts.ShowMacrosInCodeCompletion = Args.hasArg(OPT_code_completion_macros);
1341   Opts.ShowCodePatternsInCodeCompletion
1342     = Args.hasArg(OPT_code_completion_patterns);
1343   Opts.ShowGlobalSymbolsInCodeCompletion
1344     = !Args.hasArg(OPT_no_code_completion_globals);
1345   Opts.ShowStats = Args.hasArg(OPT_print_stats);
1346   Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
1347   Opts.ShowVersion = Args.hasArg(OPT_version);
1348   Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1349   Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
1350   Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
1351 
1352   Opts.ARCMTAction = FrontendOptions::ARCMT_None;
1353   if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
1354                                      OPT_arcmt_modify,
1355                                      OPT_arcmt_migrate)) {
1356     switch (A->getOption().getID()) {
1357     default:
1358       llvm_unreachable("missed a case");
1359     case OPT_arcmt_check:
1360       Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
1361       break;
1362     case OPT_arcmt_modify:
1363       Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
1364       break;
1365     case OPT_arcmt_migrate:
1366       Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
1367       break;
1368     }
1369   }
1370   Opts.ARCMTMigrateDir = Args.getLastArgValue(OPT_arcmt_migrate_directory);
1371   Opts.ARCMTMigrateReportOut
1372     = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
1373   Opts.ARCMTMigrateEmitARCErrors
1374     = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
1375 
1376   InputKind DashX = IK_None;
1377   if (const Arg *A = Args.getLastArg(OPT_x)) {
1378     DashX = llvm::StringSwitch<InputKind>(A->getValue(Args))
1379       .Case("c", IK_C)
1380       .Case("cl", IK_OpenCL)
1381       .Case("cuda", IK_CUDA)
1382       .Case("c++", IK_CXX)
1383       .Case("objective-c", IK_ObjC)
1384       .Case("objective-c++", IK_ObjCXX)
1385       .Case("cpp-output", IK_PreprocessedC)
1386       .Case("assembler-with-cpp", IK_Asm)
1387       .Case("c++-cpp-output", IK_PreprocessedCXX)
1388       .Case("objective-c-cpp-output", IK_PreprocessedObjC)
1389       .Case("objc-cpp-output", IK_PreprocessedObjC)
1390       .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX)
1391       .Case("objc++-cpp-output", IK_PreprocessedObjCXX)
1392       .Case("c-header", IK_C)
1393       .Case("cl-header", IK_OpenCL)
1394       .Case("objective-c-header", IK_ObjC)
1395       .Case("c++-header", IK_CXX)
1396       .Case("objective-c++-header", IK_ObjCXX)
1397       .Case("ast", IK_AST)
1398       .Case("ir", IK_LLVM_IR)
1399       .Default(IK_None);
1400     if (DashX == IK_None)
1401       Diags.Report(diag::err_drv_invalid_value)
1402         << A->getAsString(Args) << A->getValue(Args);
1403   }
1404 
1405   // '-' is the default input if none is given.
1406   std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
1407   Opts.Inputs.clear();
1408   if (Inputs.empty())
1409     Inputs.push_back("-");
1410   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1411     InputKind IK = DashX;
1412     if (IK == IK_None) {
1413       IK = FrontendOptions::getInputKindForExtension(
1414         StringRef(Inputs[i]).rsplit('.').second);
1415       // FIXME: Remove this hack.
1416       if (i == 0)
1417         DashX = IK;
1418     }
1419     Opts.Inputs.push_back(std::make_pair(IK, Inputs[i]));
1420   }
1421 
1422   return DashX;
1423 }
1424 
1425 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1426                                                  void *MainAddr) {
1427   llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
1428 
1429   if (!P.isEmpty()) {
1430     P.eraseComponent();  // Remove /clang from foo/bin/clang
1431     P.eraseComponent();  // Remove /bin   from foo/bin
1432 
1433     // Get foo/lib/clang/<version>/include
1434     P.appendComponent("lib");
1435     P.appendComponent("clang");
1436     P.appendComponent(CLANG_VERSION_STRING);
1437   }
1438 
1439   return P.str();
1440 }
1441 
1442 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
1443   using namespace cc1options;
1444   Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
1445   Opts.Verbose = Args.hasArg(OPT_v);
1446   Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
1447   Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
1448   Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
1449   if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
1450     Opts.UseLibcxx = (strcmp(A->getValue(Args), "libc++") == 0);
1451   Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
1452   Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodule_cache_path);
1453   Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
1454 
1455   // Add -I..., -F..., and -index-header-map options in order.
1456   bool IsIndexHeaderMap = false;
1457   for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F,
1458                                              OPT_index_header_map),
1459        ie = Args.filtered_end(); it != ie; ++it) {
1460     if ((*it)->getOption().matches(OPT_index_header_map)) {
1461       // -index-header-map applies to the next -I or -F.
1462       IsIndexHeaderMap = true;
1463       continue;
1464     }
1465 
1466     frontend::IncludeDirGroup Group
1467       = IsIndexHeaderMap? frontend::IndexHeaderMap : frontend::Angled;
1468 
1469     Opts.AddPath((*it)->getValue(Args), Group, true,
1470                  /*IsFramework=*/ (*it)->getOption().matches(OPT_F), false);
1471     IsIndexHeaderMap = false;
1472   }
1473 
1474   // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1475   StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
1476   for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix,
1477                                              OPT_iwithprefixbefore),
1478          ie = Args.filtered_end(); it != ie; ++it) {
1479     const Arg *A = *it;
1480     if (A->getOption().matches(OPT_iprefix))
1481       Prefix = A->getValue(Args);
1482     else if (A->getOption().matches(OPT_iwithprefix))
1483       Opts.AddPath(Prefix.str() + A->getValue(Args),
1484                    frontend::System, false, false, false);
1485     else
1486       Opts.AddPath(Prefix.str() + A->getValue(Args),
1487                    frontend::Angled, false, false, false);
1488   }
1489 
1490   for (arg_iterator it = Args.filtered_begin(OPT_idirafter),
1491          ie = Args.filtered_end(); it != ie; ++it)
1492     Opts.AddPath((*it)->getValue(Args), frontend::After, true, false, false);
1493   for (arg_iterator it = Args.filtered_begin(OPT_iquote),
1494          ie = Args.filtered_end(); it != ie; ++it)
1495     Opts.AddPath((*it)->getValue(Args), frontend::Quoted, true, false, false);
1496   for (arg_iterator it = Args.filtered_begin(OPT_isystem,
1497          OPT_iwithsysroot), ie = Args.filtered_end(); it != ie; ++it)
1498     Opts.AddPath((*it)->getValue(Args), frontend::System, true, false,
1499                  !(*it)->getOption().matches(OPT_iwithsysroot));
1500   for (arg_iterator it = Args.filtered_begin(OPT_iframework),
1501          ie = Args.filtered_end(); it != ie; ++it)
1502     Opts.AddPath((*it)->getValue(Args), frontend::System, true, true,
1503                  true);
1504 
1505   // Add the paths for the various language specific isystem flags.
1506   for (arg_iterator it = Args.filtered_begin(OPT_c_isystem),
1507        ie = Args.filtered_end(); it != ie; ++it)
1508     Opts.AddPath((*it)->getValue(Args), frontend::CSystem, true, false, true);
1509   for (arg_iterator it = Args.filtered_begin(OPT_cxx_isystem),
1510        ie = Args.filtered_end(); it != ie; ++it)
1511     Opts.AddPath((*it)->getValue(Args), frontend::CXXSystem, true, false, true);
1512   for (arg_iterator it = Args.filtered_begin(OPT_objc_isystem),
1513        ie = Args.filtered_end(); it != ie; ++it)
1514     Opts.AddPath((*it)->getValue(Args), frontend::ObjCSystem, true, false,true);
1515   for (arg_iterator it = Args.filtered_begin(OPT_objcxx_isystem),
1516        ie = Args.filtered_end(); it != ie; ++it)
1517     Opts.AddPath((*it)->getValue(Args), frontend::ObjCXXSystem, true, false,
1518                  true);
1519 
1520   // Add the internal paths from a driver that detects standard include paths.
1521   for (arg_iterator I = Args.filtered_begin(OPT_internal_isystem,
1522                                             OPT_internal_externc_isystem),
1523                     E = Args.filtered_end();
1524        I != E; ++I)
1525     Opts.AddPath((*I)->getValue(Args), frontend::System,
1526                  false, false, /*IgnoreSysRoot=*/true, /*IsInternal=*/true,
1527                  (*I)->getOption().matches(OPT_internal_externc_isystem));
1528 }
1529 
1530 void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
1531                                          LangStandard::Kind LangStd) {
1532   // Set some properties which depend solely on the input kind; it would be nice
1533   // to move these to the language standard, and have the driver resolve the
1534   // input kind + language standard.
1535   if (IK == IK_Asm) {
1536     Opts.AsmPreprocessor = 1;
1537   } else if (IK == IK_ObjC ||
1538              IK == IK_ObjCXX ||
1539              IK == IK_PreprocessedObjC ||
1540              IK == IK_PreprocessedObjCXX) {
1541     Opts.ObjC1 = Opts.ObjC2 = 1;
1542   }
1543 
1544   if (LangStd == LangStandard::lang_unspecified) {
1545     // Based on the base language, pick one.
1546     switch (IK) {
1547     case IK_None:
1548     case IK_AST:
1549     case IK_LLVM_IR:
1550       llvm_unreachable("Invalid input kind!");
1551     case IK_OpenCL:
1552       LangStd = LangStandard::lang_opencl;
1553       break;
1554     case IK_CUDA:
1555       LangStd = LangStandard::lang_cuda;
1556       break;
1557     case IK_Asm:
1558     case IK_C:
1559     case IK_PreprocessedC:
1560     case IK_ObjC:
1561     case IK_PreprocessedObjC:
1562       LangStd = LangStandard::lang_gnu99;
1563       break;
1564     case IK_CXX:
1565     case IK_PreprocessedCXX:
1566     case IK_ObjCXX:
1567     case IK_PreprocessedObjCXX:
1568       LangStd = LangStandard::lang_gnucxx98;
1569       break;
1570     }
1571   }
1572 
1573   const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1574   Opts.BCPLComment = Std.hasBCPLComments();
1575   Opts.C99 = Std.isC99();
1576   Opts.C1X = Std.isC1X();
1577   Opts.CPlusPlus = Std.isCPlusPlus();
1578   Opts.CPlusPlus0x = Std.isCPlusPlus0x();
1579   Opts.Digraphs = Std.hasDigraphs();
1580   Opts.GNUMode = Std.isGNUMode();
1581   Opts.GNUInline = !Std.isC99();
1582   Opts.HexFloats = Std.hasHexFloats();
1583   Opts.ImplicitInt = Std.hasImplicitInt();
1584 
1585   // OpenCL has some additional defaults.
1586   if (LangStd == LangStandard::lang_opencl) {
1587     Opts.OpenCL = 1;
1588     Opts.AltiVec = 0;
1589     Opts.CXXOperatorNames = 1;
1590     Opts.LaxVectorConversions = 0;
1591     Opts.DefaultFPContract = 1;
1592   }
1593 
1594   if (LangStd == LangStandard::lang_cuda)
1595     Opts.CUDA = 1;
1596 
1597   // OpenCL and C++ both have bool, true, false keywords.
1598   Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1599 
1600   Opts.GNUKeywords = Opts.GNUMode;
1601   Opts.CXXOperatorNames = Opts.CPlusPlus;
1602 
1603   // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1604   // is specified, or -std is set to a conforming mode.
1605   Opts.Trigraphs = !Opts.GNUMode;
1606 
1607   Opts.DollarIdents = !Opts.AsmPreprocessor;
1608 }
1609 
1610 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
1611                           DiagnosticsEngine &Diags) {
1612   // FIXME: Cleanup per-file based stuff.
1613   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
1614   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
1615     LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
1616 #define LANGSTANDARD(id, name, desc, features) \
1617       .Case(name, LangStandard::lang_##id)
1618 #include "clang/Frontend/LangStandards.def"
1619       .Default(LangStandard::lang_unspecified);
1620     if (LangStd == LangStandard::lang_unspecified)
1621       Diags.Report(diag::err_drv_invalid_value)
1622         << A->getAsString(Args) << A->getValue(Args);
1623     else {
1624       // Valid standard, check to make sure language and standard are compatable.
1625       const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1626       switch (IK) {
1627       case IK_C:
1628       case IK_ObjC:
1629       case IK_PreprocessedC:
1630       case IK_PreprocessedObjC:
1631         if (!(Std.isC89() || Std.isC99()))
1632           Diags.Report(diag::err_drv_argument_not_allowed_with)
1633             << A->getAsString(Args) << "C/ObjC";
1634         break;
1635       case IK_CXX:
1636       case IK_ObjCXX:
1637       case IK_PreprocessedCXX:
1638       case IK_PreprocessedObjCXX:
1639         if (!Std.isCPlusPlus())
1640           Diags.Report(diag::err_drv_argument_not_allowed_with)
1641             << A->getAsString(Args) << "C++/ObjC++";
1642         break;
1643       case IK_OpenCL:
1644         if (!Std.isC99())
1645           Diags.Report(diag::err_drv_argument_not_allowed_with)
1646             << A->getAsString(Args) << "OpenCL";
1647         break;
1648       case IK_CUDA:
1649         if (!Std.isCPlusPlus())
1650           Diags.Report(diag::err_drv_argument_not_allowed_with)
1651             << A->getAsString(Args) << "CUDA";
1652         break;
1653       default:
1654         break;
1655       }
1656     }
1657   }
1658 
1659   if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
1660     if (strcmp(A->getValue(Args), "CL1.1") != 0) {
1661       Diags.Report(diag::err_drv_invalid_value)
1662         << A->getAsString(Args) << A->getValue(Args);
1663     }
1664   }
1665 
1666   CompilerInvocation::setLangDefaults(Opts, IK, LangStd);
1667 
1668   // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1669   // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1670   // while a subset (the non-C++ GNU keywords) is provided by GCC's
1671   // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1672   // name, as it doesn't seem a useful distinction.
1673   Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
1674                                   Opts.GNUKeywords);
1675 
1676   if (Args.hasArg(OPT_fno_operator_names))
1677     Opts.CXXOperatorNames = 0;
1678 
1679   if (Opts.ObjC1) {
1680     if (Args.hasArg(OPT_fobjc_gc_only))
1681       Opts.setGC(LangOptions::GCOnly);
1682     else if (Args.hasArg(OPT_fobjc_gc))
1683       Opts.setGC(LangOptions::HybridGC);
1684     else if (Args.hasArg(OPT_fobjc_arc)) {
1685       Opts.ObjCAutoRefCount = 1;
1686       if (Args.hasArg(OPT_fobjc_fragile_abi))
1687         Diags.Report(diag::err_arc_nonfragile_abi);
1688     }
1689 
1690     if (Args.hasArg(OPT_fobjc_runtime_has_weak))
1691       Opts.ObjCRuntimeHasWeak = 1;
1692 
1693     if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
1694       Opts.ObjCInferRelatedResultType = 0;
1695   }
1696 
1697   if (Args.hasArg(OPT_fgnu89_inline))
1698     Opts.GNUInline = 1;
1699 
1700   if (Args.hasArg(OPT_fapple_kext)) {
1701     if (!Opts.CPlusPlus)
1702       Diags.Report(diag::warn_c_kext);
1703     else
1704       Opts.AppleKext = 1;
1705   }
1706 
1707   if (Args.hasArg(OPT_print_ivar_layout))
1708     Opts.ObjCGCBitmapPrint = 1;
1709   if (Args.hasArg(OPT_fno_constant_cfstrings))
1710     Opts.NoConstantCFStrings = 1;
1711 
1712   if (Args.hasArg(OPT_faltivec))
1713     Opts.AltiVec = 1;
1714 
1715   if (Args.hasArg(OPT_pthread))
1716     Opts.POSIXThreads = 1;
1717 
1718   if (Args.hasArg(OPT_fdelayed_template_parsing))
1719     Opts.DelayedTemplateParsing = 1;
1720 
1721   StringRef Vis = Args.getLastArgValue(OPT_fvisibility, "default");
1722   if (Vis == "default")
1723     Opts.setVisibilityMode(DefaultVisibility);
1724   else if (Vis == "hidden")
1725     Opts.setVisibilityMode(HiddenVisibility);
1726   else if (Vis == "protected")
1727     Opts.setVisibilityMode(ProtectedVisibility);
1728   else
1729     Diags.Report(diag::err_drv_invalid_value)
1730       << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
1731 
1732   if (Args.hasArg(OPT_fvisibility_inlines_hidden))
1733     Opts.InlineVisibilityHidden = 1;
1734 
1735   if (Args.hasArg(OPT_ftrapv)) {
1736     Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
1737     // Set the handler, if one is specified.
1738     Opts.OverflowHandler =
1739         Args.getLastArgValue(OPT_ftrapv_handler);
1740   }
1741   else if (Args.hasArg(OPT_fwrapv))
1742     Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
1743 
1744   if (Args.hasArg(OPT_trigraphs))
1745     Opts.Trigraphs = 1;
1746 
1747   Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
1748                                    OPT_fno_dollars_in_identifiers,
1749                                    Opts.DollarIdents);
1750   Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
1751   Opts.MicrosoftExt
1752     = Args.hasArg(OPT_fms_extensions) || Args.hasArg(OPT_fms_compatibility);
1753   Opts.MicrosoftMode = Args.hasArg(OPT_fms_compatibility);
1754   Opts.MSCVersion = Args.getLastArgIntValue(OPT_fmsc_version, 0, Diags);
1755   Opts.Borland = Args.hasArg(OPT_fborland_extensions);
1756   Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
1757   Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
1758                                    Opts.ConstStrings);
1759   if (Args.hasArg(OPT_fno_lax_vector_conversions))
1760     Opts.LaxVectorConversions = 0;
1761   if (Args.hasArg(OPT_fno_threadsafe_statics))
1762     Opts.ThreadsafeStatics = 0;
1763   Opts.Exceptions = Args.hasArg(OPT_fexceptions);
1764   Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
1765   Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
1766   Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
1767   Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
1768 
1769   Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
1770   Opts.Blocks = Args.hasArg(OPT_fblocks);
1771   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
1772   Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
1773   Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
1774   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
1775   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
1776   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
1777   Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
1778   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
1779   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
1780   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
1781   Opts.MathErrno = Args.hasArg(OPT_fmath_errno);
1782   Opts.InstantiationDepth = Args.getLastArgIntValue(OPT_ftemplate_depth, 1024,
1783                                                     Diags);
1784   Opts.ConstexprCallDepth = Args.getLastArgIntValue(OPT_fconstexpr_depth, 512,
1785                                                     Diags);
1786   Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
1787   Opts.NumLargeByValueCopy = Args.getLastArgIntValue(OPT_Wlarge_by_value_copy,
1788                                                     0, Diags);
1789   Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
1790   Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
1791   Opts.ObjCConstantStringClass =
1792     Args.getLastArgValue(OPT_fconstant_string_class);
1793   Opts.ObjCNonFragileABI = !Args.hasArg(OPT_fobjc_fragile_abi);
1794   if (Opts.ObjCNonFragileABI)
1795     Opts.ObjCNonFragileABI2 = true;
1796   Opts.ObjCDefaultSynthProperties =
1797     Args.hasArg(OPT_fobjc_default_synthesize_properties);
1798   Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
1799   Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
1800   Opts.PackStruct = Args.getLastArgIntValue(OPT_fpack_struct, 0, Diags);
1801   Opts.PICLevel = Args.getLastArgIntValue(OPT_pic_level, 0, Diags);
1802   Opts.Static = Args.hasArg(OPT_static_define);
1803   Opts.DumpRecordLayouts = Args.hasArg(OPT_fdump_record_layouts);
1804   Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
1805   Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
1806   Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
1807   Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
1808   Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
1809   Opts.OptimizeSize = 0;
1810   Opts.MRTD = Args.hasArg(OPT_mrtd);
1811   Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
1812   Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
1813   Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
1814   Opts.AddressSanitizer = Args.hasArg(OPT_faddress_sanitizer);
1815   Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
1816   Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name);
1817 
1818   // Record whether the __DEPRECATED define was requested.
1819   Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
1820                                  OPT_fno_deprecated_macro,
1821                                  Opts.Deprecated);
1822 
1823   // FIXME: Eliminate this dependency.
1824   unsigned Opt = getOptimizationLevel(Args, IK, Diags);
1825   Opts.Optimize = Opt != 0;
1826 
1827   // This is the __NO_INLINE__ define, which just depends on things like the
1828   // optimization level and -fno-inline, not actually whether the backend has
1829   // inlining enabled.
1830   //
1831   // FIXME: This is affected by other options (-fno-inline).
1832   Opts.NoInline = !Opt;
1833 
1834   unsigned SSP = Args.getLastArgIntValue(OPT_stack_protector, 0, Diags);
1835   switch (SSP) {
1836   default:
1837     Diags.Report(diag::err_drv_invalid_value)
1838       << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
1839     break;
1840   case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
1841   case 1: Opts.setStackProtector(LangOptions::SSPOn);  break;
1842   case 2: Opts.setStackProtector(LangOptions::SSPReq); break;
1843   }
1844 }
1845 
1846 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
1847                                   FileManager &FileMgr,
1848                                   DiagnosticsEngine &Diags) {
1849   using namespace cc1options;
1850   Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
1851   Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
1852   if (const Arg *A = Args.getLastArg(OPT_token_cache))
1853       Opts.TokenCache = A->getValue(Args);
1854   else
1855     Opts.TokenCache = Opts.ImplicitPTHInclude;
1856   Opts.UsePredefines = !Args.hasArg(OPT_undef);
1857   Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
1858   Opts.AutoModuleImport = Args.hasArg(OPT_fauto_module_import);
1859   Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
1860 
1861   Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
1862   for (arg_iterator it = Args.filtered_begin(OPT_error_on_deserialized_pch_decl),
1863          ie = Args.filtered_end(); it != ie; ++it) {
1864     const Arg *A = *it;
1865     Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue(Args));
1866   }
1867 
1868   if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
1869     StringRef Value(A->getValue(Args));
1870     size_t Comma = Value.find(',');
1871     unsigned Bytes = 0;
1872     unsigned EndOfLine = 0;
1873 
1874     if (Comma == StringRef::npos ||
1875         Value.substr(0, Comma).getAsInteger(10, Bytes) ||
1876         Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
1877       Diags.Report(diag::err_drv_preamble_format);
1878     else {
1879       Opts.PrecompiledPreambleBytes.first = Bytes;
1880       Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
1881     }
1882   }
1883 
1884   // Add macros from the command line.
1885   for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
1886          ie = Args.filtered_end(); it != ie; ++it) {
1887     if ((*it)->getOption().matches(OPT_D))
1888       Opts.addMacroDef((*it)->getValue(Args));
1889     else
1890       Opts.addMacroUndef((*it)->getValue(Args));
1891   }
1892 
1893   Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
1894 
1895   // Add the ordered list of -includes.
1896   for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
1897                                              OPT_include_pth),
1898          ie = Args.filtered_end(); it != ie; ++it) {
1899     const Arg *A = *it;
1900     // PCH is handled specially, we need to extra the original include path.
1901     if (A->getOption().matches(OPT_include_pch)) {
1902       std::string OriginalFile =
1903         ASTReader::getOriginalSourceFile(A->getValue(Args), FileMgr, Diags);
1904       if (OriginalFile.empty())
1905         continue;
1906 
1907       Opts.Includes.push_back(OriginalFile);
1908     } else
1909       Opts.Includes.push_back(A->getValue(Args));
1910   }
1911 
1912   for (arg_iterator it = Args.filtered_begin(OPT_chain_include),
1913          ie = Args.filtered_end(); it != ie; ++it) {
1914     const Arg *A = *it;
1915     Opts.ChainedIncludes.push_back(A->getValue(Args));
1916   }
1917 
1918   // Include 'altivec.h' if -faltivec option present
1919   if (Args.hasArg(OPT_faltivec))
1920     Opts.Includes.push_back("altivec.h");
1921 
1922   for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
1923          ie = Args.filtered_end(); it != ie; ++it) {
1924     const Arg *A = *it;
1925     std::pair<StringRef,StringRef> Split =
1926       StringRef(A->getValue(Args)).split(';');
1927 
1928     if (Split.second.empty()) {
1929       Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
1930       continue;
1931     }
1932 
1933     Opts.addRemappedFile(Split.first, Split.second);
1934   }
1935 
1936   if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
1937     StringRef Name = A->getValue(Args);
1938     unsigned Library = llvm::StringSwitch<unsigned>(Name)
1939       .Case("libc++", ARCXX_libcxx)
1940       .Case("libstdc++", ARCXX_libstdcxx)
1941       .Case("none", ARCXX_nolib)
1942       .Default(~0U);
1943     if (Library == ~0U)
1944       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1945     else
1946       Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
1947   }
1948 }
1949 
1950 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
1951                                         ArgList &Args) {
1952   using namespace cc1options;
1953   Opts.ShowCPP = !Args.hasArg(OPT_dM);
1954   Opts.ShowComments = Args.hasArg(OPT_C);
1955   Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
1956   Opts.ShowMacroComments = Args.hasArg(OPT_CC);
1957   Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
1958 }
1959 
1960 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
1961   using namespace cc1options;
1962   Opts.ABI = Args.getLastArgValue(OPT_target_abi);
1963   Opts.CXXABI = Args.getLastArgValue(OPT_cxx_abi);
1964   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
1965   Opts.Features = Args.getAllArgValues(OPT_target_feature);
1966   Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
1967   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
1968 
1969   // Use the default target triple if unspecified.
1970   if (Opts.Triple.empty())
1971     Opts.Triple = llvm::sys::getDefaultTargetTriple();
1972 }
1973 
1974 //
1975 
1976 void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
1977                                         const char *const *ArgBegin,
1978                                         const char *const *ArgEnd,
1979                                         DiagnosticsEngine &Diags) {
1980   // Parse the arguments.
1981   llvm::OwningPtr<OptTable> Opts(createCC1OptTable());
1982   unsigned MissingArgIndex, MissingArgCount;
1983   llvm::OwningPtr<InputArgList> Args(
1984     Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount));
1985 
1986   // Check for missing argument error.
1987   if (MissingArgCount)
1988     Diags.Report(diag::err_drv_missing_argument)
1989       << Args->getArgString(MissingArgIndex) << MissingArgCount;
1990 
1991   // Issue errors on unknown arguments.
1992   for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
1993          ie = Args->filtered_end(); it != ie; ++it)
1994     Diags.Report(diag::err_drv_unknown_argument) << (*it)->getAsString(*Args);
1995 
1996   ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags);
1997   ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args);
1998   ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags);
1999   ParseFileSystemArgs(Res.getFileSystemOpts(), *Args);
2000   // FIXME: We shouldn't have to pass the DashX option around here
2001   InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags);
2002   ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, DashX, Diags);
2003   ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args);
2004   if (DashX != IK_AST && DashX != IK_LLVM_IR) {
2005     ParseLangArgs(*Res.getLangOpts(), *Args, DashX, Diags);
2006     if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
2007       Res.getLangOpts()->ObjCExceptions = 1;
2008   }
2009   // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
2010   // PCH file and find the original header name. Remove the need to do that in
2011   // ParsePreprocessorArgs and remove the FileManager
2012   // parameters from the function and the "FileManager.h" #include.
2013   FileManager FileMgr(Res.getFileSystemOpts());
2014   ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, FileMgr, Diags);
2015   ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args);
2016   ParseTargetArgs(Res.getTargetOpts(), *Args);
2017 }
2018 
2019 namespace {
2020 
2021   class ModuleSignature {
2022     llvm::SmallVector<uint64_t, 16> Data;
2023     unsigned CurBit;
2024     uint64_t CurValue;
2025 
2026   public:
2027     ModuleSignature() : CurBit(0), CurValue(0) { }
2028 
2029     void add(uint64_t Value, unsigned Bits);
2030     void add(StringRef Value);
2031     void flush();
2032 
2033     llvm::APInt getAsInteger() const;
2034   };
2035 }
2036 
2037 void ModuleSignature::add(uint64_t Value, unsigned int NumBits) {
2038   CurValue |= Value << CurBit;
2039   if (CurBit + NumBits < 64) {
2040     CurBit += NumBits;
2041     return;
2042   }
2043 
2044   // Add the current word.
2045   Data.push_back(CurValue);
2046 
2047   if (CurBit)
2048     CurValue = Value >> (64-CurBit);
2049   else
2050     CurValue = 0;
2051   CurBit = (CurBit+NumBits) & 63;
2052 }
2053 
2054 void ModuleSignature::flush() {
2055   if (CurBit == 0)
2056     return;
2057 
2058   Data.push_back(CurValue);
2059   CurBit = 0;
2060   CurValue = 0;
2061 }
2062 
2063 void ModuleSignature::add(StringRef Value) {
2064   for (StringRef::iterator I = Value.begin(), IEnd = Value.end(); I != IEnd;++I)
2065     add(*I, 8);
2066 }
2067 
2068 llvm::APInt ModuleSignature::getAsInteger() const {
2069   return llvm::APInt(Data.size() * 64, Data);
2070 }
2071 
2072 std::string CompilerInvocation::getModuleHash() const {
2073   ModuleSignature Signature;
2074 
2075   // Start the signature with the compiler version.
2076   Signature.add(getClangFullRepositoryVersion());
2077 
2078   // Extend the signature with the language options
2079 #define LANGOPT(Name, Bits, Default, Description) \
2080   Signature.add(LangOpts->Name, Bits);
2081 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
2082   Signature.add(static_cast<unsigned>(LangOpts->get##Name()), Bits);
2083 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
2084 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
2085 #include "clang/Basic/LangOptions.def"
2086 
2087   // Extend the signature with the target triple
2088   llvm::Triple T(TargetOpts.Triple);
2089   Signature.add((unsigned)T.getArch(), 5);
2090   Signature.add((unsigned)T.getVendor(), 4);
2091   Signature.add((unsigned)T.getOS(), 5);
2092   Signature.add((unsigned)T.getEnvironment(), 4);
2093 
2094   // Extend the signature with preprocessor options.
2095   Signature.add(getPreprocessorOpts().UsePredefines, 1);
2096   Signature.add(getPreprocessorOpts().DetailedRecord, 1);
2097 
2098   // Hash the preprocessor defines.
2099   // FIXME: This is terrible. Use an MD5 sum of the preprocessor defines.
2100   std::vector<StringRef> MacroDefs;
2101   for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
2102             I = getPreprocessorOpts().Macros.begin(),
2103          IEnd = getPreprocessorOpts().Macros.end();
2104        I != IEnd; ++I) {
2105     if (!I->second)
2106       MacroDefs.push_back(I->first);
2107   }
2108   llvm::array_pod_sort(MacroDefs.begin(), MacroDefs.end());
2109 
2110   unsigned PPHashResult = 0;
2111   for (unsigned I = 0, N = MacroDefs.size(); I != N; ++I)
2112     PPHashResult = llvm::HashString(MacroDefs[I], PPHashResult);
2113   Signature.add(PPHashResult, 32);
2114 
2115   // We've generated the signature. Treat it as one large APInt that we'll
2116   // encode in base-36 and return.
2117   Signature.flush();
2118   return Signature.getAsInteger().toString(36, /*Signed=*/false);
2119 }
2120