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.IsInternal) {
 573         assert(E.Group == frontend::System && "Unexpected header search group");
 574         if (E.ImplicitExternC)
 575           Res.push_back("-internal-externc-isystem");
 576         else
 577           Res.push_back("-internal-isystem");
 578       } else {
 579         if (E.Group != frontend::Angled && E.Group != frontend::System)
 580           llvm::report_fatal_error("Invalid option set!");
 581         Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
 582                       "-iwithprefix");
 583       }
 584     }
 585     Res.push_back(E.Path);
 586   }
 587
 588   if (!Opts.ResourceDir.empty()) {
 589     Res.push_back("-resource-dir");
 590     Res.push_back(Opts.ResourceDir);
 591   }
 592   if (!Opts.ModuleCachePath.empty()) {
 593     Res.push_back("-fmodule-cache-path");
 594     Res.push_back(Opts.ModuleCachePath);
 595   }
 596   if (!Opts.UseStandardSystemIncludes)
 597     Res.push_back("-nostdsysteminc");
 598   if (!Opts.UseStandardCXXIncludes)
 599     Res.push_back("-nostdinc++");
 600   if (Opts.UseLibcxx)
 601     Res.push_back("-stdlib=libc++");
 602   if (Opts.Verbose)
 603     Res.push_back("-v");
 604 }
 605
 606 static void LangOptsToArgs(const LangOptions &Opts,
 607                            std::vector<std::string> &Res) {
 608   LangOptions DefaultLangOpts;
 609
 610   // FIXME: Need to set -std to get all the implicit options.
 611
 612   // FIXME: We want to only pass options relative to the defaults, which
 613   // requires constructing a target. :(
 614   //
 615   // It would be better to push the all target specific choices into the driver,
 616   // so that everything below that was more uniform.
 617
 618   if (Opts.Trigraphs)
 619     Res.push_back("-trigraphs");
 620   // Implicit based on the input kind:
 621   //   AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
 622   // Implicit based on the input language standard:
 623   //   BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
 624   if (Opts.DollarIdents)
 625     Res.push_back("-fdollars-in-identifiers");
 626   if (Opts.GNUMode && !Opts.GNUKeywords)
 627     Res.push_back("-fno-gnu-keywords");
 628   if (!Opts.GNUMode && Opts.GNUKeywords)
 629     Res.push_back("-fgnu-keywords");
 630   if (Opts.MicrosoftExt)
 631     Res.push_back("-fms-extensions");
 632   if (Opts.MSCVersion != 0)
 633     Res.push_back("-fmsc-version=" + llvm::utostr(Opts.MSCVersion));
 634   if (Opts.Borland)
 635     Res.push_back("-fborland-extensions");
 636   if (!Opts.ObjCNonFragileABI)
 637     Res.push_back("-fobjc-fragile-abi");
 638   if (Opts.ObjCDefaultSynthProperties)
 639     Res.push_back("-fobjc-default-synthesize-properties");
 640   // NoInline is implicit.
 641   if (!Opts.CXXOperatorNames)
 642     Res.push_back("-fno-operator-names");
 643   if (Opts.PascalStrings)
 644     Res.push_back("-fpascal-strings");
 645   if (Opts.CatchUndefined)
 646     Res.push_back("-fcatch-undefined-behavior");
 647   if (Opts.WritableStrings)
 648     Res.push_back("-fwritable-strings");
 649   if (Opts.ConstStrings)
 650     Res.push_back("-fconst-strings");
 651   if (!Opts.LaxVectorConversions)
 652     Res.push_back("-fno-lax-vector-conversions");
 653   if (Opts.AltiVec)
 654     Res.push_back("-faltivec");
 655   if (Opts.Exceptions)
 656     Res.push_back("-fexceptions");
 657   if (Opts.ObjCExceptions)
 658     Res.push_back("-fobjc-exceptions");
 659   if (Opts.CXXExceptions)
 660     Res.push_back("-fcxx-exceptions");
 661   if (Opts.SjLjExceptions)
 662     Res.push_back("-fsjlj-exceptions");
 663   if (Opts.TraditionalCPP)
 664     Res.push_back("-traditional-cpp");
 665   if (!Opts.RTTI)
 666     Res.push_back("-fno-rtti");
 667   if (Opts.MSBitfields)
 668     Res.push_back("-mms-bitfields");
 669   if (!Opts.NeXTRuntime)
 670     Res.push_back("-fgnu-runtime");
 671   if (Opts.Freestanding)
 672     Res.push_back("-ffreestanding");
 673   if (Opts.NoBuiltin)
 674     Res.push_back("-fno-builtin");
 675   if (!Opts.AssumeSaneOperatorNew)
 676     Res.push_back("-fno-assume-sane-operator-new");
 677   if (!Opts.ThreadsafeStatics)
 678     Res.push_back("-fno-threadsafe-statics");
 679   if (Opts.POSIXThreads)
 680     Res.push_back("-pthread");
 681   if (Opts.Blocks)
 682     Res.push_back("-fblocks");
 683   if (Opts.BlocksRuntimeOptional)
 684     Res.push_back("-fblocks-runtime-optional");
 685   if (Opts.EmitAllDecls)
 686     Res.push_back("-femit-all-decls");
 687   if (Opts.MathErrno)
 688     Res.push_back("-fmath-errno");
 689   switch (Opts.getSignedOverflowBehavior()) {
 690   case LangOptions::SOB_Undefined: break;
 691   case LangOptions::SOB_Defined:   Res.push_back("-fwrapv"); break;
 692   case LangOptions::SOB_Trapping:
 693     Res.push_back("-ftrapv"); break;
 694     if (!Opts.OverflowHandler.empty()) {
 695       Res.push_back("-ftrapv-handler");
 696       Res.push_back(Opts.OverflowHandler);
 697     }
 698   }
 699   if (Opts.HeinousExtensions)
 700     Res.push_back("-fheinous-gnu-extensions");
 701   // Optimize is implicit.
 702   // OptimizeSize is implicit.
 703   if (Opts.Static)
 704     Res.push_back("-static-define");
 705   if (Opts.DumpRecordLayouts)
 706     Res.push_back("-fdump-record-layouts");
 707   if (Opts.DumpVTableLayouts)
 708     Res.push_back("-fdump-vtable-layouts");
 709   if (Opts.NoBitFieldTypeAlign)
 710     Res.push_back("-fno-bitfield-type-alignment");
 711   if (Opts.PICLevel) {
 712     Res.push_back("-pic-level");
 713     Res.push_back(llvm::utostr(Opts.PICLevel));
 714   }
 715   if (Opts.ObjCGCBitmapPrint)
 716     Res.push_back("-print-ivar-layout");
 717   if (Opts.NoConstantCFStrings)
 718     Res.push_back("-fno-constant-cfstrings");
 719   if (!Opts.AccessControl)
 720     Res.push_back("-fno-access-control");
 721   if (!Opts.CharIsSigned)
 722     Res.push_back("-fno-signed-char");
 723   if (Opts.ShortWChar)
 724     Res.push_back("-fshort-wchar");
 725   if (!Opts.ElideConstructors)
 726     Res.push_back("-fno-elide-constructors");
 727   if (Opts.getGC() != LangOptions::NonGC) {
 728     if (Opts.getGC() == LangOptions::HybridGC) {
 729       Res.push_back("-fobjc-gc");
 730     } else {
 731       assert(Opts.getGC() == LangOptions::GCOnly && "Invalid GC mode!");
 732       Res.push_back("-fobjc-gc-only");
 733     }
 734   }
 735   if (Opts.ObjCAutoRefCount)
 736     Res.push_back("-fobjc-arc");
 737   if (Opts.ObjCRuntimeHasWeak)
 738     Res.push_back("-fobjc-runtime-has-weak");
 739   if (!Opts.ObjCInferRelatedResultType)
 740     Res.push_back("-fno-objc-infer-related-result-type");
 741
 742   if (Opts.AppleKext)
 743     Res.push_back("-fapple-kext");
 744
 745   if (Opts.getVisibilityMode() != DefaultVisibility) {
 746     Res.push_back("-fvisibility");
 747     if (Opts.getVisibilityMode() == HiddenVisibility) {
 748       Res.push_back("hidden");
 749     } else {
 750       assert(Opts.getVisibilityMode() == ProtectedVisibility &&
 751              "Invalid visibility!");
 752       Res.push_back("protected");
 753     }
 754   }
 755   if (Opts.InlineVisibilityHidden)
 756     Res.push_back("-fvisibility-inlines-hidden");
 757
 758   if (Opts.getStackProtector() != 0) {
 759     Res.push_back("-stack-protector");
 760     Res.push_back(llvm::utostr(Opts.getStackProtector()));
 761   }
 762   if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) {
 763     Res.push_back("-ftemplate-depth");
 764     Res.push_back(llvm::utostr(Opts.InstantiationDepth));
 765   }
 766   if (!Opts.ObjCConstantStringClass.empty()) {
 767     Res.push_back("-fconstant-string-class");
 768     Res.push_back(Opts.ObjCConstantStringClass);
 769   }
 770   if (Opts.FakeAddressSpaceMap)
 771     Res.push_back("-ffake-address-space-map");
 772   if (Opts.ParseUnknownAnytype)
 773     Res.push_back("-funknown-anytype");
 774   if (Opts.DebuggerSupport)
 775     Res.push_back("-fdebugger-support");
 776   if (Opts.DelayedTemplateParsing)
 777     Res.push_back("-fdelayed-template-parsing");
 778   if (Opts.Deprecated)
 779     Res.push_back("-fdeprecated-macro");
 780 }
 781
 782 static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
 783                                    std::vector<std::string> &Res) {
 784   for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
 785     Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") +
 786                   Opts.Macros[i].first);
 787   for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
 788     // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
 789     Res.push_back("-include");
 790     Res.push_back(Opts.Includes[i]);
 791   }
 792   for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) {
 793     Res.push_back("-imacros");
 794     Res.push_back(Opts.MacroIncludes[i]);
 795   }
 796   if (!Opts.UsePredefines)
 797     Res.push_back("-undef");
 798   if (Opts.DetailedRecord)
 799     Res.push_back("-detailed-preprocessing-record");
 800   if (!Opts.ImplicitPCHInclude.empty()) {
 801     Res.push_back("-include-pch");
 802     Res.push_back(Opts.ImplicitPCHInclude);
 803   }
 804   if (!Opts.ImplicitPTHInclude.empty()) {
 805     Res.push_back("-include-pth");
 806     Res.push_back(Opts.ImplicitPTHInclude);
 807   }
 808   if (!Opts.TokenCache.empty()) {
 809     if (Opts.ImplicitPTHInclude.empty()) {
 810       Res.push_back("-token-cache");
 811       Res.push_back(Opts.TokenCache);
 812     } else
 813       assert(Opts.ImplicitPTHInclude == Opts.TokenCache &&
 814              "Unsupported option combination!");
 815   }
 816   for (unsigned i = 0, e = Opts.ChainedIncludes.size(); i != e; ++i) {
 817     Res.push_back("-chain-include");
 818     Res.push_back(Opts.ChainedIncludes[i]);
 819   }
 820   for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) {
 821     Res.push_back("-remap-file");
 822     Res.push_back(Opts.RemappedFiles[i].first + ";" +
 823                   Opts.RemappedFiles[i].second);
 824   }
 825 }
 826
 827 static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
 828                                          std::vector<std::string> &Res) {
 829   if (!Opts.ShowCPP && !Opts.ShowMacros)
 830     llvm::report_fatal_error("Invalid option combination!");
 831
 832   if (Opts.ShowCPP && Opts.ShowMacros)
 833     Res.push_back("-dD");
 834   else if (!Opts.ShowCPP && Opts.ShowMacros)
 835     Res.push_back("-dM");
 836
 837   if (!Opts.ShowLineMarkers)
 838     Res.push_back("-P");
 839   if (Opts.ShowComments)
 840     Res.push_back("-C");
 841   if (Opts.ShowMacroComments)
 842     Res.push_back("-CC");
 843 }
 844
 845 static void TargetOptsToArgs(const TargetOptions &Opts,
 846                              std::vector<std::string> &Res) {
 847   Res.push_back("-triple");
 848   Res.push_back(Opts.Triple);
 849   if (!Opts.CPU.empty()) {
 850     Res.push_back("-target-cpu");
 851     Res.push_back(Opts.CPU);
 852   }
 853   if (!Opts.ABI.empty()) {
 854     Res.push_back("-target-abi");
 855     Res.push_back(Opts.ABI);
 856   }
 857   if (!Opts.LinkerVersion.empty()) {
 858     Res.push_back("-target-linker-version");
 859     Res.push_back(Opts.LinkerVersion);
 860   }
 861   if (!Opts.CXXABI.empty()) {
 862     Res.push_back("-cxx-abi");
 863     Res.push_back(Opts.CXXABI);
 864   }
 865   for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) {
 866     Res.push_back("-target-feature");
 867     Res.push_back(Opts.Features[i]);
 868   }
 869 }
 870
 871 void CompilerInvocation::toArgs(std::vector<std::string> &Res) {
 872   AnalyzerOptsToArgs(getAnalyzerOpts(), Res);
 873   CodeGenOptsToArgs(getCodeGenOpts(), Res);
 874   DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res);
 875   DiagnosticOptsToArgs(getDiagnosticOpts(), Res);
 876   FileSystemOptsToArgs(getFileSystemOpts(), Res);
 877   FrontendOptsToArgs(getFrontendOpts(), Res);
 878   HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res);
 879   LangOptsToArgs(getLangOpts(), Res);
 880   PreprocessorOptsToArgs(getPreprocessorOpts(), Res);
 881   PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res);
 882   TargetOptsToArgs(getTargetOpts(), Res);
 883 }
 884
 885 //===----------------------------------------------------------------------===//
 886 // Deserialization (to args)
 887 //===----------------------------------------------------------------------===//
 888
 889 using namespace clang::driver;
 890 using namespace clang::driver::cc1options;
 891
 892 //
 893
 894 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
 895                                      DiagnosticsEngine &Diags) {
 896   unsigned DefaultOpt = 0;
 897   if (IK == IK_OpenCL && !Args.hasArg(OPT_cl_opt_disable))
 898     DefaultOpt = 2;
 899   // -Os/-Oz implies -O2
 900   return (Args.hasArg(OPT_Os) || Args.hasArg (OPT_Oz)) ? 2 :
 901     Args.getLastArgIntValue(OPT_O, DefaultOpt, Diags);
 902 }
 903
 904 static void ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
 905                               DiagnosticsEngine &Diags) {
 906   using namespace cc1options;
 907
 908   if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
 909     StringRef Name = A->getValue(Args);
 910     AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
 911 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
 912       .Case(CMDFLAG, NAME##Model)
 913 #include "clang/Frontend/Analyses.def"
 914       .Default(NumStores);
 915     // FIXME: Error handling.
 916     if (Value == NumStores)
 917       Diags.Report(diag::err_drv_invalid_value)
 918         << A->getAsString(Args) << Name;
 919     else
 920       Opts.AnalysisStoreOpt = Value;
 921   }
 922
 923   if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
 924     StringRef Name = A->getValue(Args);
 925     AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
 926 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
 927       .Case(CMDFLAG, NAME##Model)
 928 #include "clang/Frontend/Analyses.def"
 929       .Default(NumConstraints);
 930     // FIXME: Error handling.
 931     if (Value == NumConstraints)
 932       Diags.Report(diag::err_drv_invalid_value)
 933         << A->getAsString(Args) << Name;
 934     else
 935       Opts.AnalysisConstraintsOpt = Value;
 936   }
 937
 938   if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
 939     StringRef Name = A->getValue(Args);
 940     AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
 941 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
 942       .Case(CMDFLAG, PD_##NAME)
 943 #include "clang/Frontend/Analyses.def"
 944       .Default(NUM_ANALYSIS_DIAG_CLIENTS);
 945     // FIXME: Error handling.
 946     if (Value == NUM_ANALYSIS_DIAG_CLIENTS)
 947       Diags.Report(diag::err_drv_invalid_value)
 948         << A->getAsString(Args) << Name;
 949     else
 950       Opts.AnalysisDiagOpt = Value;
 951   }
 952
 953   if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
 954     StringRef Name = A->getValue(Args);
 955     AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
 956 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
 957       .Case(CMDFLAG, NAME)
 958 #include "clang/Frontend/Analyses.def"
 959       .Default(NumPurgeModes);
 960     // FIXME: Error handling.
 961     if (Value == NumPurgeModes)
 962       Diags.Report(diag::err_drv_invalid_value)
 963         << A->getAsString(Args) << Name;
 964     else
 965       Opts.AnalysisPurgeOpt = Value;
 966   }
 967
 968   Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
 969   Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
 970   Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
 971   Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
 972   Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
 973   Opts.AnalyzeNestedBlocks =
 974     Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
 975   Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume);
 976   Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
 977   Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
 978   Opts.CFGAddImplicitDtors = Args.hasArg(OPT_analysis_CFGAddImplicitDtors);
 979   Opts.CFGAddInitializers = Args.hasArg(OPT_analysis_CFGAddInitializers);
 980   Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
 981   Opts.MaxNodes = Args.getLastArgIntValue(OPT_analyzer_max_nodes, 150000,Diags);
 982   Opts.MaxLoop = Args.getLastArgIntValue(OPT_analyzer_max_loop, 4, Diags);
 983   Opts.EagerlyTrimEGraph = !Args.hasArg(OPT_analyzer_no_eagerly_trim_egraph);
 984   Opts.InlineCall = Args.hasArg(OPT_analyzer_inline_call);
 985
 986   Opts.CheckersControlList.clear();
 987   for (arg_iterator it = Args.filtered_begin(OPT_analyzer_checker,
 988                                              OPT_analyzer_disable_checker),
 989          ie = Args.filtered_end(); it != ie; ++it) {
 990     const Arg *A = *it;
 991     A->claim();
 992     bool enable = (A->getOption().getID() == OPT_analyzer_checker);
 993     // We can have a list of comma separated checker names, e.g:
 994     // '-analyzer-checker=cocoa,unix'
 995     StringRef checkerList = A->getValue(Args);
 996     SmallVector<StringRef, 4> checkers;
 997     checkerList.split(checkers, ",");
 998     for (unsigned i = 0, e = checkers.size(); i != e; ++i)
 999       Opts.CheckersControlList.push_back(std::make_pair(checkers[i], enable));
1000   }
1001 }
1002
1003 static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
1004                              DiagnosticsEngine &Diags) {
1005   using namespace cc1options;
1006
1007   Opts.OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
1008   if (Opts.OptimizationLevel > 3) {
1009     Diags.Report(diag::err_drv_invalid_value)
1010       << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel;
1011     Opts.OptimizationLevel = 3;
1012   }
1013
1014   // We must always run at least the always inlining pass.
1015   Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining
1016     : CodeGenOptions::OnlyAlwaysInlining;
1017
1018   Opts.DebugInfo = Args.hasArg(OPT_g);
1019   Opts.LimitDebugInfo = Args.hasArg(OPT_flimit_debug_info);
1020   Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
1021   Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
1022   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
1023   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
1024     OPT_fuse_register_sized_bitfield_access);
1025   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
1026   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
1027   Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
1028   Opts.NoCommon = Args.hasArg(OPT_fno_common);
1029   Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
1030   Opts.OptimizeSize = Args.hasArg(OPT_Os);
1031   Opts.OptimizeSize = Args.hasArg(OPT_Oz) ? 2 : Opts.OptimizeSize;
1032   Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
1033                             Args.hasArg(OPT_ffreestanding));
1034   Opts.UnrollLoops = Args.hasArg(OPT_funroll_loops) ||
1035                      (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize);
1036
1037   Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
1038   Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
1039   Opts.ObjCRuntimeHasARC = Args.hasArg(OPT_fobjc_runtime_has_arc);
1040   Opts.ObjCRuntimeHasTerminate = Args.hasArg(OPT_fobjc_runtime_has_terminate);
1041   Opts.CUDAIsDevice = Args.hasArg(OPT_fcuda_is_device);
1042   Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
1043   Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
1044   Opts.CodeModel = Args.getLastArgValue(OPT_mcode_model);
1045   Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
1046   Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim);
1047   Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
1048   Opts.HiddenWeakVTables = Args.hasArg(OPT_fhidden_weak_vtables);
1049   Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable);
1050   Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
1051   Opts.NoInfsFPMath = Opts.NoNaNsFPMath = Args.hasArg(OPT_cl_finite_math_only)||
1052                                           Args.hasArg(OPT_cl_fast_relaxed_math);
1053   Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
1054   Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
1055   Opts.NumRegisterParameters = Args.getLastArgIntValue(OPT_mregparm, 0, Diags);
1056   Opts.NoGlobalMerge = Args.hasArg(OPT_mno_global_merge);
1057   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
1058   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
1059   Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
1060   Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
1061   Opts.NoDwarf2CFIAsm = Args.hasArg(OPT_fno_dwarf2_cfi_asm);
1062   Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
1063   Opts.UnsafeFPMath = Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
1064                       Args.hasArg(OPT_cl_fast_relaxed_math);
1065   Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
1066   Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
1067
1068   Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections);
1069   Opts.DataSections = Args.hasArg(OPT_fdata_sections);
1070
1071   Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
1072   Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
1073
1074   Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
1075   Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
1076   Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
1077   Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
1078   Opts.CoverageFile = Args.getLastArgValue(OPT_coverage_file);
1079
1080   if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
1081     StringRef Name = A->getValue(Args);
1082     unsigned Method = llvm::StringSwitch<unsigned>(Name)
1083       .Case("legacy", CodeGenOptions::Legacy)
1084       .Case("non-legacy", CodeGenOptions::NonLegacy)
1085       .Case("mixed", CodeGenOptions::Mixed)
1086       .Default(~0U);
1087     if (Method == ~0U)
1088       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1089     else
1090       Opts.ObjCDispatchMethod = Method;
1091   }
1092 }
1093
1094 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
1095                                       ArgList &Args) {
1096   using namespace cc1options;
1097   Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
1098   Opts.Targets = Args.getAllArgValues(OPT_MT);
1099   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
1100   Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
1101   Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
1102   Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
1103   Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
1104 }
1105
1106 static void ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
1107                                 DiagnosticsEngine &Diags) {
1108   using namespace cc1options;
1109   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
1110   Opts.IgnoreWarnings = Args.hasArg(OPT_w);
1111   Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
1112   Opts.Pedantic = Args.hasArg(OPT_pedantic);
1113   Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
1114   Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
1115   Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics);
1116   Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
1117                                  OPT_fno_show_column,
1118                                  /*Default=*/true);
1119   Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
1120   Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
1121   Opts.ShowNames = Args.hasArg(OPT_fdiagnostics_show_name);
1122   Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
1123
1124   // Default behavior is to not to show note include stacks.
1125   Opts.ShowNoteIncludeStack = false;
1126   if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1127                                OPT_fno_diagnostics_show_note_include_stack))
1128     if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1129       Opts.ShowNoteIncludeStack = true;
1130
1131   StringRef ShowOverloads =
1132     Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1133   if (ShowOverloads == "best")
1134     Opts.ShowOverloads = DiagnosticsEngine::Ovl_Best;
1135   else if (ShowOverloads == "all")
1136     Opts.ShowOverloads = DiagnosticsEngine::Ovl_All;
1137   else
1138     Diags.Report(diag::err_drv_invalid_value)
1139       << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1140       << ShowOverloads;
1141
1142   StringRef ShowCategory =
1143     Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
1144   if (ShowCategory == "none")
1145     Opts.ShowCategories = 0;
1146   else if (ShowCategory == "id")
1147     Opts.ShowCategories = 1;
1148   else if (ShowCategory == "name")
1149     Opts.ShowCategories = 2;
1150   else
1151     Diags.Report(diag::err_drv_invalid_value)
1152       << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1153       << ShowCategory;
1154
1155   StringRef Format =
1156     Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1157   if (Format == "clang")
1158     Opts.Format = DiagnosticOptions::Clang;
1159   else if (Format == "msvc")
1160     Opts.Format = DiagnosticOptions::Msvc;
1161   else if (Format == "vi")
1162     Opts.Format = DiagnosticOptions::Vi;
1163   else
1164     Diags.Report(diag::err_drv_invalid_value)
1165       << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1166       << Format;
1167
1168   Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
1169   Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
1170   Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
1171   Opts.ErrorLimit = Args.getLastArgIntValue(OPT_ferror_limit, 0, Diags);
1172   Opts.MacroBacktraceLimit
1173     = Args.getLastArgIntValue(OPT_fmacro_backtrace_limit,
1174                          DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
1175   Opts.TemplateBacktraceLimit
1176     = Args.getLastArgIntValue(OPT_ftemplate_backtrace_limit,
1177                          DiagnosticOptions::DefaultTemplateBacktraceLimit,
1178                          Diags);
1179   Opts.TabStop = Args.getLastArgIntValue(OPT_ftabstop,
1180                                     DiagnosticOptions::DefaultTabStop, Diags);
1181   if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
1182     Diags.Report(diag::warn_ignoring_ftabstop_value)
1183       << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
1184     Opts.TabStop = DiagnosticOptions::DefaultTabStop;
1185   }
1186   Opts.MessageLength = Args.getLastArgIntValue(OPT_fmessage_length, 0, Diags);
1187   Opts.DumpBuildInformation = Args.getLastArgValue(OPT_dump_build_information);
1188   Opts.Warnings = Args.getAllArgValues(OPT_W);
1189 }
1190
1191 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1192   Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1193 }
1194
1195 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
1196                                    DiagnosticsEngine &Diags) {
1197   using namespace cc1options;
1198   Opts.ProgramAction = frontend::ParseSyntaxOnly;
1199   if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1200     switch (A->getOption().getID()) {
1201     default:
1202       llvm_unreachable("Invalid option in group!");
1203     case OPT_ast_dump:
1204       Opts.ProgramAction = frontend::ASTDump; break;
1205     case OPT_ast_dump_xml:
1206       Opts.ProgramAction = frontend::ASTDumpXML; break;
1207     case OPT_ast_print:
1208       Opts.ProgramAction = frontend::ASTPrint; break;
1209     case OPT_ast_view:
1210       Opts.ProgramAction = frontend::ASTView; break;
1211     case OPT_dump_raw_tokens:
1212       Opts.ProgramAction = frontend::DumpRawTokens; break;
1213     case OPT_dump_tokens:
1214       Opts.ProgramAction = frontend::DumpTokens; break;
1215     case OPT_S:
1216       Opts.ProgramAction = frontend::EmitAssembly; break;
1217     case OPT_emit_llvm_bc:
1218       Opts.ProgramAction = frontend::EmitBC; break;
1219     case OPT_emit_html:
1220       Opts.ProgramAction = frontend::EmitHTML; break;
1221     case OPT_emit_llvm:
1222       Opts.ProgramAction = frontend::EmitLLVM; break;
1223     case OPT_emit_llvm_only:
1224       Opts.ProgramAction = frontend::EmitLLVMOnly; break;
1225     case OPT_emit_codegen_only:
1226       Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
1227     case OPT_emit_obj:
1228       Opts.ProgramAction = frontend::EmitObj; break;
1229     case OPT_fixit_EQ:
1230       Opts.FixItSuffix = A->getValue(Args);
1231       // fall-through!
1232     case OPT_fixit:
1233       Opts.ProgramAction = frontend::FixIt; break;
1234     case OPT_emit_module:
1235       Opts.ProgramAction = frontend::GenerateModule; break;
1236     case OPT_emit_pch:
1237       Opts.ProgramAction = frontend::GeneratePCH; break;
1238     case OPT_emit_pth:
1239       Opts.ProgramAction = frontend::GeneratePTH; break;
1240     case OPT_init_only:
1241       Opts.ProgramAction = frontend::InitOnly; break;
1242     case OPT_fsyntax_only:
1243       Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
1244     case OPT_print_decl_contexts:
1245       Opts.ProgramAction = frontend::PrintDeclContext; break;
1246     case OPT_print_preamble:
1247       Opts.ProgramAction = frontend::PrintPreamble; break;
1248     case OPT_E:
1249       Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
1250     case OPT_rewrite_macros:
1251       Opts.ProgramAction = frontend::RewriteMacros; break;
1252     case OPT_rewrite_objc:
1253       Opts.ProgramAction = frontend::RewriteObjC; break;
1254     case OPT_rewrite_test:
1255       Opts.ProgramAction = frontend::RewriteTest; break;
1256     case OPT_analyze:
1257       Opts.ProgramAction = frontend::RunAnalysis; break;
1258     case OPT_Eonly:
1259       Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
1260     }
1261   }
1262
1263   if (const Arg* A = Args.getLastArg(OPT_plugin)) {
1264     Opts.Plugins.push_back(A->getValue(Args,0));
1265     Opts.ProgramAction = frontend::PluginAction;
1266     Opts.ActionName = A->getValue(Args);
1267
1268     for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
1269            end = Args.filtered_end(); it != end; ++it) {
1270       if ((*it)->getValue(Args, 0) == Opts.ActionName)
1271         Opts.PluginArgs.push_back((*it)->getValue(Args, 1));
1272     }
1273   }
1274
1275   Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
1276   Opts.AddPluginArgs.resize(Opts.AddPluginActions.size());
1277   for (int i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
1278     for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
1279            end = Args.filtered_end(); it != end; ++it) {
1280       if ((*it)->getValue(Args, 0) == Opts.AddPluginActions[i])
1281         Opts.AddPluginArgs[i].push_back((*it)->getValue(Args, 1));
1282     }
1283   }
1284
1285   if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1286     Opts.CodeCompletionAt =
1287       ParsedSourceLocation::FromString(A->getValue(Args));
1288     if (Opts.CodeCompletionAt.FileName.empty())
1289       Diags.Report(diag::err_drv_invalid_value)
1290         << A->getAsString(Args) << A->getValue(Args);
1291   }
1292   Opts.DisableFree = Args.hasArg(OPT_disable_free);
1293
1294   Opts.OutputFile = Args.getLastArgValue(OPT_o);
1295   Opts.Plugins = Args.getAllArgValues(OPT_load);
1296   Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
1297   Opts.ShowHelp = Args.hasArg(OPT_help);
1298   Opts.ShowMacrosInCodeCompletion = Args.hasArg(OPT_code_completion_macros);
1299   Opts.ShowCodePatternsInCodeCompletion
1300     = Args.hasArg(OPT_code_completion_patterns);
1301   Opts.ShowGlobalSymbolsInCodeCompletion
1302     = !Args.hasArg(OPT_no_code_completion_globals);
1303   Opts.ShowStats = Args.hasArg(OPT_print_stats);
1304   Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
1305   Opts.ShowVersion = Args.hasArg(OPT_version);
1306   Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1307   Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
1308   Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
1309
1310   Opts.ARCMTAction = FrontendOptions::ARCMT_None;
1311   if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
1312                                      OPT_arcmt_modify,
1313                                      OPT_arcmt_migrate)) {
1314     switch (A->getOption().getID()) {
1315     default:
1316       llvm_unreachable("missed a case");
1317     case OPT_arcmt_check:
1318       Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
1319       break;
1320     case OPT_arcmt_modify:
1321       Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
1322       break;
1323     case OPT_arcmt_migrate:
1324       Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
1325       break;
1326     }
1327   }
1328   Opts.ARCMTMigrateDir = Args.getLastArgValue(OPT_arcmt_migrate_directory);
1329   Opts.ARCMTMigrateReportOut
1330     = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
1331   Opts.ARCMTMigrateEmitARCErrors
1332     = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
1333
1334   InputKind DashX = IK_None;
1335   if (const Arg *A = Args.getLastArg(OPT_x)) {
1336     DashX = llvm::StringSwitch<InputKind>(A->getValue(Args))
1337       .Case("c", IK_C)
1338       .Case("cl", IK_OpenCL)
1339       .Case("cuda", IK_CUDA)
1340       .Case("c++", IK_CXX)
1341       .Case("objective-c", IK_ObjC)
1342       .Case("objective-c++", IK_ObjCXX)
1343       .Case("cpp-output", IK_PreprocessedC)
1344       .Case("assembler-with-cpp", IK_Asm)
1345       .Case("c++-cpp-output", IK_PreprocessedCXX)
1346       .Case("objective-c-cpp-output", IK_PreprocessedObjC)
1347       .Case("objc-cpp-output", IK_PreprocessedObjC)
1348       .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX)
1349       .Case("objc++-cpp-output", IK_PreprocessedObjCXX)
1350       .Case("c-header", IK_C)
1351       .Case("cl-header", IK_OpenCL)
1352       .Case("objective-c-header", IK_ObjC)
1353       .Case("c++-header", IK_CXX)
1354       .Case("objective-c++-header", IK_ObjCXX)
1355       .Case("ast", IK_AST)
1356       .Case("ir", IK_LLVM_IR)
1357       .Default(IK_None);
1358     if (DashX == IK_None)
1359       Diags.Report(diag::err_drv_invalid_value)
1360         << A->getAsString(Args) << A->getValue(Args);
1361   }
1362
1363   // '-' is the default input if none is given.
1364   std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
1365   Opts.Inputs.clear();
1366   if (Inputs.empty())
1367     Inputs.push_back("-");
1368   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1369     InputKind IK = DashX;
1370     if (IK == IK_None) {
1371       IK = FrontendOptions::getInputKindForExtension(
1372         StringRef(Inputs[i]).rsplit('.').second);
1373       // FIXME: Remove this hack.
1374       if (i == 0)
1375         DashX = IK;
1376     }
1377     Opts.Inputs.push_back(std::make_pair(IK, Inputs[i]));
1378   }
1379
1380   return DashX;
1381 }
1382
1383 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1384                                                  void *MainAddr) {
1385   llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
1386
1387   if (!P.isEmpty()) {
1388     P.eraseComponent();  // Remove /clang from foo/bin/clang
1389     P.eraseComponent();  // Remove /bin   from foo/bin
1390
1391     // Get foo/lib/clang/<version>/include
1392     P.appendComponent("lib");
1393     P.appendComponent("clang");
1394     P.appendComponent(CLANG_VERSION_STRING);
1395   }
1396
1397   return P.str();
1398 }
1399
1400 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
1401   using namespace cc1options;
1402   Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
1403   Opts.Verbose = Args.hasArg(OPT_v);
1404   Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
1405   Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
1406   Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
1407   if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
1408     Opts.UseLibcxx = (strcmp(A->getValue(Args), "libc++") == 0);
1409   Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
1410   Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodule_cache_path);
1411   Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
1412
1413   // Add -I..., -F..., and -index-header-map options in order.
1414   bool IsIndexHeaderMap = false;
1415   for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F,
1416                                              OPT_index_header_map),
1417        ie = Args.filtered_end(); it != ie; ++it) {
1418     if ((*it)->getOption().matches(OPT_index_header_map)) {
1419       // -index-header-map applies to the next -I or -F.
1420       IsIndexHeaderMap = true;
1421       continue;
1422     }
1423
1424     frontend::IncludeDirGroup Group
1425       = IsIndexHeaderMap? frontend::IndexHeaderMap : frontend::Angled;
1426
1427     Opts.AddPath((*it)->getValue(Args), Group, true,
1428                  /*IsFramework=*/ (*it)->getOption().matches(OPT_F), false);
1429     IsIndexHeaderMap = false;
1430   }
1431
1432   // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1433   StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
1434   for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix,
1435                                              OPT_iwithprefixbefore),
1436          ie = Args.filtered_end(); it != ie; ++it) {
1437     const Arg *A = *it;
1438     if (A->getOption().matches(OPT_iprefix))
1439       Prefix = A->getValue(Args);
1440     else if (A->getOption().matches(OPT_iwithprefix))
1441       Opts.AddPath(Prefix.str() + A->getValue(Args),
1442                    frontend::System, false, false, false);
1443     else
1444       Opts.AddPath(Prefix.str() + A->getValue(Args),
1445                    frontend::Angled, false, false, false);
1446   }
1447
1448   for (arg_iterator it = Args.filtered_begin(OPT_idirafter),
1449          ie = Args.filtered_end(); it != ie; ++it)
1450     Opts.AddPath((*it)->getValue(Args), frontend::After, true, false, false);
1451   for (arg_iterator it = Args.filtered_begin(OPT_iquote),
1452          ie = Args.filtered_end(); it != ie; ++it)
1453     Opts.AddPath((*it)->getValue(Args), frontend::Quoted, true, false, false);
1454   for (arg_iterator it = Args.filtered_begin(OPT_isystem,
1455          OPT_iwithsysroot), ie = Args.filtered_end(); it != ie; ++it)
1456     Opts.AddPath((*it)->getValue(Args), frontend::System, true, false,
1457                  !(*it)->getOption().matches(OPT_iwithsysroot));
1458
1459   // Add the paths for the various language specific isystem flags.
1460   for (arg_iterator it = Args.filtered_begin(OPT_c_isystem),
1461        ie = Args.filtered_end(); it != ie; ++it)
1462     Opts.AddPath((*it)->getValue(Args), frontend::CSystem, true, false, true);
1463   for (arg_iterator it = Args.filtered_begin(OPT_cxx_isystem),
1464        ie = Args.filtered_end(); it != ie; ++it)
1465     Opts.AddPath((*it)->getValue(Args), frontend::CXXSystem, true, false, true);
1466   for (arg_iterator it = Args.filtered_begin(OPT_objc_isystem),
1467        ie = Args.filtered_end(); it != ie; ++it)
1468     Opts.AddPath((*it)->getValue(Args), frontend::ObjCSystem, true, false,true);
1469   for (arg_iterator it = Args.filtered_begin(OPT_objcxx_isystem),
1470        ie = Args.filtered_end(); it != ie; ++it)
1471     Opts.AddPath((*it)->getValue(Args), frontend::ObjCXXSystem, true, false,
1472                  true);
1473
1474   // Add the internal paths from a driver that detects standard include paths.
1475   for (arg_iterator I = Args.filtered_begin(OPT_internal_isystem,
1476                                             OPT_internal_externc_isystem),
1477                     E = Args.filtered_end();
1478        I != E; ++I)
1479     Opts.AddPath((*I)->getValue(Args), frontend::System,
1480                  false, false, /*IgnoreSysRoot=*/true, /*IsInternal=*/true,
1481                  (*I)->getOption().matches(OPT_internal_externc_isystem));
1482 }
1483
1484 void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
1485                                          LangStandard::Kind LangStd) {
1486   // Set some properties which depend solely on the input kind; it would be nice
1487   // to move these to the language standard, and have the driver resolve the
1488   // input kind + language standard.
1489   if (IK == IK_Asm) {
1490     Opts.AsmPreprocessor = 1;
1491   } else if (IK == IK_ObjC ||
1492              IK == IK_ObjCXX ||
1493              IK == IK_PreprocessedObjC ||
1494              IK == IK_PreprocessedObjCXX) {
1495     Opts.ObjC1 = Opts.ObjC2 = 1;
1496   }
1497
1498   if (LangStd == LangStandard::lang_unspecified) {
1499     // Based on the base language, pick one.
1500     switch (IK) {
1501     case IK_None:
1502     case IK_AST:
1503     case IK_LLVM_IR:
1504       llvm_unreachable("Invalid input kind!");
1505     case IK_OpenCL:
1506       LangStd = LangStandard::lang_opencl;
1507       break;
1508     case IK_CUDA:
1509       LangStd = LangStandard::lang_cuda;
1510       break;
1511     case IK_Asm:
1512     case IK_C:
1513     case IK_PreprocessedC:
1514     case IK_ObjC:
1515     case IK_PreprocessedObjC:
1516       LangStd = LangStandard::lang_gnu99;
1517       break;
1518     case IK_CXX:
1519     case IK_PreprocessedCXX:
1520     case IK_ObjCXX:
1521     case IK_PreprocessedObjCXX:
1522       LangStd = LangStandard::lang_gnucxx98;
1523       break;
1524     }
1525   }
1526
1527   const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1528   Opts.BCPLComment = Std.hasBCPLComments();
1529   Opts.C99 = Std.isC99();
1530   Opts.C1X = Std.isC1X();
1531   Opts.CPlusPlus = Std.isCPlusPlus();
1532   Opts.CPlusPlus0x = Std.isCPlusPlus0x();
1533   Opts.Digraphs = Std.hasDigraphs();
1534   Opts.GNUMode = Std.isGNUMode();
1535   Opts.GNUInline = !Std.isC99();
1536   Opts.HexFloats = Std.hasHexFloats();
1537   Opts.ImplicitInt = Std.hasImplicitInt();
1538
1539   // OpenCL has some additional defaults.
1540   if (LangStd == LangStandard::lang_opencl) {
1541     Opts.OpenCL = 1;
1542     Opts.AltiVec = 0;
1543     Opts.CXXOperatorNames = 1;
1544     Opts.LaxVectorConversions = 0;
1545     Opts.DefaultFPContract = 1;
1546   }
1547
1548   if (LangStd == LangStandard::lang_cuda)
1549     Opts.CUDA = 1;
1550
1551   // OpenCL and C++ both have bool, true, false keywords.
1552   Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1553
1554   Opts.GNUKeywords = Opts.GNUMode;
1555   Opts.CXXOperatorNames = Opts.CPlusPlus;
1556
1557   // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1558   // is specified, or -std is set to a conforming mode.
1559   Opts.Trigraphs = !Opts.GNUMode;
1560
1561   Opts.DollarIdents = !Opts.AsmPreprocessor;
1562 }
1563
1564 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
1565                           DiagnosticsEngine &Diags) {
1566   // FIXME: Cleanup per-file based stuff.
1567   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
1568   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
1569     LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
1570 #define LANGSTANDARD(id, name, desc, features) \
1571       .Case(name, LangStandard::lang_##id)
1572 #include "clang/Frontend/LangStandards.def"
1573       .Default(LangStandard::lang_unspecified);
1574     if (LangStd == LangStandard::lang_unspecified)
1575       Diags.Report(diag::err_drv_invalid_value)
1576         << A->getAsString(Args) << A->getValue(Args);
1577     else {
1578       // Valid standard, check to make sure language and standard are compatable.
1579       const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1580       switch (IK) {
1581       case IK_C:
1582       case IK_ObjC:
1583       case IK_PreprocessedC:
1584       case IK_PreprocessedObjC:
1585         if (!(Std.isC89() || Std.isC99()))
1586           Diags.Report(diag::err_drv_argument_not_allowed_with)
1587             << A->getAsString(Args) << "C/ObjC";
1588         break;
1589       case IK_CXX:
1590       case IK_ObjCXX:
1591       case IK_PreprocessedCXX:
1592       case IK_PreprocessedObjCXX:
1593         if (!Std.isCPlusPlus())
1594           Diags.Report(diag::err_drv_argument_not_allowed_with)
1595             << A->getAsString(Args) << "C++/ObjC++";
1596         break;
1597       case IK_OpenCL:
1598         if (!Std.isC99())
1599           Diags.Report(diag::err_drv_argument_not_allowed_with)
1600             << A->getAsString(Args) << "OpenCL";
1601         break;
1602       case IK_CUDA:
1603         if (!Std.isCPlusPlus())
1604           Diags.Report(diag::err_drv_argument_not_allowed_with)
1605             << A->getAsString(Args) << "CUDA";
1606         break;
1607       default:
1608         break;
1609       }
1610     }
1611   }
1612
1613   if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
1614     if (strcmp(A->getValue(Args), "CL1.1") != 0) {
1615       Diags.Report(diag::err_drv_invalid_value)
1616         << A->getAsString(Args) << A->getValue(Args);
1617     }
1618   }
1619
1620   CompilerInvocation::setLangDefaults(Opts, IK, LangStd);
1621
1622   // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1623   // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1624   // while a subset (the non-C++ GNU keywords) is provided by GCC's
1625   // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1626   // name, as it doesn't seem a useful distinction.
1627   Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
1628                                   Opts.GNUKeywords);
1629
1630   if (Args.hasArg(OPT_fno_operator_names))
1631     Opts.CXXOperatorNames = 0;
1632
1633   if (Opts.ObjC1) {
1634     if (Args.hasArg(OPT_fobjc_gc_only))
1635       Opts.setGC(LangOptions::GCOnly);
1636     else if (Args.hasArg(OPT_fobjc_gc))
1637       Opts.setGC(LangOptions::HybridGC);
1638     else if (Args.hasArg(OPT_fobjc_arc)) {
1639       Opts.ObjCAutoRefCount = 1;
1640       if (Args.hasArg(OPT_fobjc_fragile_abi))
1641         Diags.Report(diag::err_arc_nonfragile_abi);
1642     }
1643
1644     if (Args.hasArg(OPT_fobjc_runtime_has_weak))
1645       Opts.ObjCRuntimeHasWeak = 1;
1646
1647     if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
1648       Opts.ObjCInferRelatedResultType = 0;
1649   }
1650
1651   if (Args.hasArg(OPT_fgnu89_inline))
1652     Opts.GNUInline = 1;
1653
1654   if (Args.hasArg(OPT_fapple_kext)) {
1655     if (!Opts.CPlusPlus)
1656       Diags.Report(diag::warn_c_kext);
1657     else
1658       Opts.AppleKext = 1;
1659   }
1660
1661   if (Args.hasArg(OPT_print_ivar_layout))
1662     Opts.ObjCGCBitmapPrint = 1;
1663   if (Args.hasArg(OPT_fno_constant_cfstrings))
1664     Opts.NoConstantCFStrings = 1;
1665
1666   if (Args.hasArg(OPT_faltivec))
1667     Opts.AltiVec = 1;
1668
1669   if (Args.hasArg(OPT_pthread))
1670     Opts.POSIXThreads = 1;
1671
1672   if (Args.hasArg(OPT_fdelayed_template_parsing))
1673     Opts.DelayedTemplateParsing = 1;
1674
1675   StringRef Vis = Args.getLastArgValue(OPT_fvisibility, "default");
1676   if (Vis == "default")
1677     Opts.setVisibilityMode(DefaultVisibility);
1678   else if (Vis == "hidden")
1679     Opts.setVisibilityMode(HiddenVisibility);
1680   else if (Vis == "protected")
1681     Opts.setVisibilityMode(ProtectedVisibility);
1682   else
1683     Diags.Report(diag::err_drv_invalid_value)
1684       << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
1685
1686   if (Args.hasArg(OPT_fvisibility_inlines_hidden))
1687     Opts.InlineVisibilityHidden = 1;
1688
1689   if (Args.hasArg(OPT_ftrapv)) {
1690     Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
1691     // Set the handler, if one is specified.
1692     Opts.OverflowHandler =
1693         Args.getLastArgValue(OPT_ftrapv_handler);
1694   }
1695   else if (Args.hasArg(OPT_fwrapv))
1696     Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
1697
1698   if (Args.hasArg(OPT_trigraphs))
1699     Opts.Trigraphs = 1;
1700
1701   Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
1702                                    OPT_fno_dollars_in_identifiers,
1703                                    Opts.DollarIdents);
1704   Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
1705   Opts.MicrosoftExt = Args.hasArg(OPT_fms_extensions);
1706   Opts.MicrosoftMode = Args.hasArg(OPT_fms_compatibility);
1707   Opts.MSCVersion = Args.getLastArgIntValue(OPT_fmsc_version, 0, Diags);
1708   Opts.Borland = Args.hasArg(OPT_fborland_extensions);
1709   Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
1710   Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
1711                                    Opts.ConstStrings);
1712   if (Args.hasArg(OPT_fno_lax_vector_conversions))
1713     Opts.LaxVectorConversions = 0;
1714   if (Args.hasArg(OPT_fno_threadsafe_statics))
1715     Opts.ThreadsafeStatics = 0;
1716   Opts.Exceptions = Args.hasArg(OPT_fexceptions);
1717   Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
1718   Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
1719   Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
1720   Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
1721
1722   Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
1723   Opts.Blocks = Args.hasArg(OPT_fblocks);
1724   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
1725   Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
1726   Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
1727   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
1728   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
1729   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
1730   Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
1731   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
1732   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
1733   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
1734   Opts.MathErrno = Args.hasArg(OPT_fmath_errno);
1735   Opts.InstantiationDepth = Args.getLastArgIntValue(OPT_ftemplate_depth, 1024,
1736                                                Diags);
1737   Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
1738   Opts.NumLargeByValueCopy = Args.getLastArgIntValue(OPT_Wlarge_by_value_copy,
1739                                                     0, Diags);
1740   Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
1741   Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
1742   Opts.ObjCConstantStringClass =
1743     Args.getLastArgValue(OPT_fconstant_string_class);
1744   Opts.ObjCNonFragileABI = !Args.hasArg(OPT_fobjc_fragile_abi);
1745   if (Opts.ObjCNonFragileABI)
1746     Opts.ObjCNonFragileABI2 = true;
1747   Opts.ObjCDefaultSynthProperties =
1748     Args.hasArg(OPT_fobjc_default_synthesize_properties);
1749   Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
1750   Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
1751   Opts.PackStruct = Args.getLastArgIntValue(OPT_fpack_struct, 0, Diags);
1752   Opts.PICLevel = Args.getLastArgIntValue(OPT_pic_level, 0, Diags);
1753   Opts.Static = Args.hasArg(OPT_static_define);
1754   Opts.DumpRecordLayouts = Args.hasArg(OPT_fdump_record_layouts);
1755   Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
1756   Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
1757   Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
1758   Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
1759   Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
1760   Opts.OptimizeSize = 0;
1761   Opts.MRTD = Args.hasArg(OPT_mrtd);
1762   Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
1763   Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
1764   Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
1765
1766   // Record whether the __DEPRECATED define was requested.
1767   Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
1768                                  OPT_fno_deprecated_macro,
1769                                  Opts.Deprecated);
1770
1771   // FIXME: Eliminate this dependency.
1772   unsigned Opt = getOptimizationLevel(Args, IK, Diags);
1773   Opts.Optimize = Opt != 0;
1774
1775   // This is the __NO_INLINE__ define, which just depends on things like the
1776   // optimization level and -fno-inline, not actually whether the backend has
1777   // inlining enabled.
1778   //
1779   // FIXME: This is affected by other options (-fno-inline).
1780   Opts.NoInline = !Opt;
1781
1782   unsigned SSP = Args.getLastArgIntValue(OPT_stack_protector, 0, Diags);
1783   switch (SSP) {
1784   default:
1785     Diags.Report(diag::err_drv_invalid_value)
1786       << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
1787     break;
1788   case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
1789   case 1: Opts.setStackProtector(LangOptions::SSPOn);  break;
1790   case 2: Opts.setStackProtector(LangOptions::SSPReq); break;
1791   }
1792 }
1793
1794 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
1795                                   FileManager &FileMgr,
1796                                   DiagnosticsEngine &Diags) {
1797   using namespace cc1options;
1798   Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
1799   Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
1800   if (const Arg *A = Args.getLastArg(OPT_token_cache))
1801       Opts.TokenCache = A->getValue(Args);
1802   else
1803     Opts.TokenCache = Opts.ImplicitPTHInclude;
1804   Opts.UsePredefines = !Args.hasArg(OPT_undef);
1805   Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
1806   Opts.AutoModuleImport = Args.hasArg(OPT_fauto_module_import);
1807   Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
1808
1809   Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
1810   for (arg_iterator it = Args.filtered_begin(OPT_error_on_deserialized_pch_decl),
1811          ie = Args.filtered_end(); it != ie; ++it) {
1812     const Arg *A = *it;
1813     Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue(Args));
1814   }
1815
1816   if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
1817     StringRef Value(A->getValue(Args));
1818     size_t Comma = Value.find(',');
1819     unsigned Bytes = 0;
1820     unsigned EndOfLine = 0;
1821
1822     if (Comma == StringRef::npos ||
1823         Value.substr(0, Comma).getAsInteger(10, Bytes) ||
1824         Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
1825       Diags.Report(diag::err_drv_preamble_format);
1826     else {
1827       Opts.PrecompiledPreambleBytes.first = Bytes;
1828       Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
1829     }
1830   }
1831
1832   // Add macros from the command line.
1833   for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
1834          ie = Args.filtered_end(); it != ie; ++it) {
1835     if ((*it)->getOption().matches(OPT_D))
1836       Opts.addMacroDef((*it)->getValue(Args));
1837     else
1838       Opts.addMacroUndef((*it)->getValue(Args));
1839   }
1840
1841   Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
1842
1843   // Add the ordered list of -includes.
1844   for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
1845                                              OPT_include_pth),
1846          ie = Args.filtered_end(); it != ie; ++it) {
1847     const Arg *A = *it;
1848     // PCH is handled specially, we need to extra the original include path.
1849     if (A->getOption().matches(OPT_include_pch)) {
1850       std::string OriginalFile =
1851         ASTReader::getOriginalSourceFile(A->getValue(Args), FileMgr, Diags);
1852       if (OriginalFile.empty())
1853         continue;
1854
1855       Opts.Includes.push_back(OriginalFile);
1856     } else
1857       Opts.Includes.push_back(A->getValue(Args));
1858   }
1859
1860   for (arg_iterator it = Args.filtered_begin(OPT_chain_include),
1861          ie = Args.filtered_end(); it != ie; ++it) {
1862     const Arg *A = *it;
1863     Opts.ChainedIncludes.push_back(A->getValue(Args));
1864   }
1865
1866   // Include 'altivec.h' if -faltivec option present
1867   if (Args.hasArg(OPT_faltivec))
1868     Opts.Includes.push_back("altivec.h");
1869
1870   for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
1871          ie = Args.filtered_end(); it != ie; ++it) {
1872     const Arg *A = *it;
1873     std::pair<StringRef,StringRef> Split =
1874       StringRef(A->getValue(Args)).split(';');
1875
1876     if (Split.second.empty()) {
1877       Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
1878       continue;
1879     }
1880
1881     Opts.addRemappedFile(Split.first, Split.second);
1882   }
1883
1884   if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
1885     StringRef Name = A->getValue(Args);
1886     unsigned Library = llvm::StringSwitch<unsigned>(Name)
1887       .Case("libc++", ARCXX_libcxx)
1888       .Case("libstdc++", ARCXX_libstdcxx)
1889       .Case("none", ARCXX_nolib)
1890       .Default(~0U);
1891     if (Library == ~0U)
1892       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1893     else
1894       Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
1895   }
1896 }
1897
1898 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
1899                                         ArgList &Args) {
1900   using namespace cc1options;
1901   Opts.ShowCPP = !Args.hasArg(OPT_dM);
1902   Opts.ShowComments = Args.hasArg(OPT_C);
1903   Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
1904   Opts.ShowMacroComments = Args.hasArg(OPT_CC);
1905   Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
1906 }
1907
1908 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
1909   using namespace cc1options;
1910   Opts.ABI = Args.getLastArgValue(OPT_target_abi);
1911   Opts.CXXABI = Args.getLastArgValue(OPT_cxx_abi);
1912   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
1913   Opts.Features = Args.getAllArgValues(OPT_target_feature);
1914   Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
1915   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
1916
1917   // Use the host triple if unspecified.
1918   if (Opts.Triple.empty())
1919     Opts.Triple = llvm::sys::getHostTriple();
1920 }
1921
1922 //
1923
1924 void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
1925                                         const char *const *ArgBegin,
1926                                         const char *const *ArgEnd,
1927                                         DiagnosticsEngine &Diags) {
1928   // Parse the arguments.
1929   llvm::OwningPtr<OptTable> Opts(createCC1OptTable());
1930   unsigned MissingArgIndex, MissingArgCount;
1931   llvm::OwningPtr<InputArgList> Args(
1932     Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount));
1933
1934   // Check for missing argument error.
1935   if (MissingArgCount)
1936     Diags.Report(diag::err_drv_missing_argument)
1937       << Args->getArgString(MissingArgIndex) << MissingArgCount;
1938
1939   // Issue errors on unknown arguments.
1940   for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
1941          ie = Args->filtered_end(); it != ie; ++it)
1942     Diags.Report(diag::err_drv_unknown_argument) << (*it)->getAsString(*Args);
1943
1944   ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags);
1945   ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args);
1946   ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags);
1947   ParseFileSystemArgs(Res.getFileSystemOpts(), *Args);
1948   // FIXME: We shouldn't have to pass the DashX option around here
1949   InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags);
1950   ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, DashX, Diags);
1951   ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args);
1952   if (DashX != IK_AST && DashX != IK_LLVM_IR) {
1953     ParseLangArgs(Res.getLangOpts(), *Args, DashX, Diags);
1954     if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
1955       Res.getLangOpts().ObjCExceptions = 1;
1956   }
1957   // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
1958   // PCH file and find the original header name. Remove the need to do that in
1959   // ParsePreprocessorArgs and remove the FileManager
1960   // parameters from the function and the "FileManager.h" #include.
1961   FileManager FileMgr(Res.getFileSystemOpts());
1962   ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, FileMgr, Diags);
1963   ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args);
1964   ParseTargetArgs(Res.getTargetOpts(), *Args);
1965 }
1966
1967 namespace {
1968
1969   class ModuleSignature {
1970     llvm::SmallVector<uint64_t, 16> Data;
1971     unsigned CurBit;
1972     uint64_t CurValue;
1973
1974   public:
1975     ModuleSignature() : CurBit(0), CurValue(0) { }
1976
1977     void add(uint64_t Value, unsigned Bits);
1978     void add(StringRef Value);
1979     void flush();
1980
1981     llvm::APInt getAsInteger() const;
1982   };
1983 }
1984
1985 void ModuleSignature::add(uint64_t Value, unsigned int NumBits) {
1986   CurValue |= Value << CurBit;
1987   if (CurBit + NumBits < 64) {
1988     CurBit += NumBits;
1989     return;
1990   }
1991
1992   // Add the current word.
1993   Data.push_back(CurValue);
1994
1995   if (CurBit)
1996     CurValue = Value >> (64-CurBit);
1997   else
1998     CurValue = 0;
1999   CurBit = (CurBit+NumBits) & 63;
2000 }
2001
2002 void ModuleSignature::flush() {
2003   if (CurBit == 0)
2004     return;
2005
2006   Data.push_back(CurValue);
2007   CurBit = 0;
2008   CurValue = 0;
2009 }
2010
2011 void ModuleSignature::add(StringRef Value) {
2012   for (StringRef::iterator I = Value.begin(), IEnd = Value.end(); I != IEnd;++I)
2013     add(*I, 8);
2014 }
2015
2016 llvm::APInt ModuleSignature::getAsInteger() const {
2017   return llvm::APInt(Data.size() * 64, Data);
2018 }
2019
2020 std::string CompilerInvocation::getModuleHash() const {
2021   ModuleSignature Signature;
2022
2023   // Start the signature with the compiler version.
2024   Signature.add(getClangFullRepositoryVersion());
2025
2026   // Extend the signature with the language options
2027 #define LANGOPT(Name, Bits, Default, Description) \
2028   Signature.add(LangOpts.Name, Bits);
2029 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
2030   Signature.add(static_cast<unsigned>(LangOpts.get##Name()), Bits);
2031 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
2032 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
2033 #include "clang/Basic/LangOptions.def"
2034
2035   // Extend the signature with the target triple
2036   llvm::Triple T(TargetOpts.Triple);
2037   Signature.add((unsigned)T.getArch(), 5);
2038   Signature.add((unsigned)T.getVendor(), 4);
2039   Signature.add((unsigned)T.getOS(), 5);
2040   Signature.add((unsigned)T.getEnvironment(), 4);
2041
2042   // Extend the signature with preprocessor options.
2043   Signature.add(getPreprocessorOpts().UsePredefines, 1);
2044   Signature.add(getPreprocessorOpts().DetailedRecord, 1);
2045
2046   // Hash the preprocessor defines.
2047   // FIXME: This is terrible. Use an MD5 sum of the preprocessor defines.
2048   std::vector<StringRef> MacroDefs;
2049   for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
2050             I = getPreprocessorOpts().Macros.begin(),
2051          IEnd = getPreprocessorOpts().Macros.end();
2052        I != IEnd; ++I) {
2053     if (!I->second)
2054       MacroDefs.push_back(I->first);
2055   }
2056   llvm::array_pod_sort(MacroDefs.begin(), MacroDefs.end());
2057
2058   unsigned PPHashResult = 0;
2059   for (unsigned I = 0, N = MacroDefs.size(); I != N; ++I)
2060     PPHashResult = llvm::HashString(MacroDefs[I], PPHashResult);
2061   Signature.add(PPHashResult, 32);
2062
2063   // We've generated the signature. Treat it as one large APInt that we'll
2064   // encode in base-36 and return.
2065   Signature.flush();
2066   return Signature.getAsInteger().toString(36, /*Signed=*/false);
2067 }