contrib/llvm/tools/clang/lib/Frontend/CompilerInvocation.cpp

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