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