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 "llvm/ADT/StringExtras.h"
  12 #include "llvm/Support/ErrorHandling.h"
  13 using namespace clang;
  14
  15 void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
  16                            const llvm::SmallVectorImpl<llvm::StringRef> &Args) {
  17   llvm::llvm_report_error("FIXME: Not yet implemented!");
  18 }
  19
  20 static const char *getAnalysisName(Analyses Kind) {
  21   switch (Kind) {
  22   default:
  23     llvm::llvm_unreachable("Unknown analysis store!");
  24 #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE)\
  25   case NAME: return CMDFLAG;
  26 #include "clang/Frontend/Analyses.def"
  27   }
  28 }
  29
  30 static const char *getAnalysisStoreName(AnalysisStores Kind) {
  31   switch (Kind) {
  32   default:
  33     llvm::llvm_unreachable("Unknown analysis store!");
  34 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
  35   case NAME##Model: return CMDFLAG;
  36 #include "clang/Frontend/Analyses.def"
  37   }
  38 }
  39
  40 static const char *getAnalysisConstraintName(AnalysisConstraints Kind) {
  41   switch (Kind) {
  42   default:
  43     llvm::llvm_unreachable("Unknown analysis constraints!");
  44 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
  45   case NAME##Model: return CMDFLAG;
  46 #include "clang/Frontend/Analyses.def"
  47   }
  48 }
  49
  50 static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) {
  51   switch (Kind) {
  52   default:
  53     llvm::llvm_unreachable("Unknown analysis client!");
  54 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
  55   case PD_##NAME: return CMDFLAG;
  56 #include "clang/Frontend/Analyses.def"
  57   }
  58 }
  59
  60 static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts,
  61                                std::vector<std::string> &Res) {
  62   for (unsigned i = 0, e = Opts.AnalysisList.size(); i != e; ++i)
  63     Res.push_back(getAnalysisName(Opts.AnalysisList[i]));
  64   if (Opts.AnalysisStoreOpt != BasicStoreModel) {
  65     Res.push_back("-analyzer-store");
  66     Res.push_back(getAnalysisStoreName(Opts.AnalysisStoreOpt));
  67   }
  68   if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {
  69     Res.push_back("-analyzer-constraints");
  70     Res.push_back(getAnalysisConstraintName(Opts.AnalysisConstraintsOpt));
  71   }
  72   if (Opts.AnalysisDiagOpt != PD_HTML) {
  73     Res.push_back("-analyzer-output");
  74     Res.push_back(getAnalysisDiagClientName(Opts.AnalysisDiagOpt));
  75   }
  76   if (!Opts.AnalyzeSpecificFunction.empty()) {
  77     Res.push_back("-analyze-function");
  78     Res.push_back(Opts.AnalyzeSpecificFunction);
  79   }
  80   if (Opts.AnalyzeAll)
  81     Res.push_back("-analyzer-opt-analyze-headers");
  82   if (Opts.AnalyzerDisplayProgress)
  83     Res.push_back("-analyzer-display-progress");
  84   if (Opts.EagerlyAssume)
  85     Res.push_back("-analyzer-eagerly-assume");
  86   if (Opts.PurgeDead)
  87     Res.push_back("-analyzer-purge-dead");
  88   if (Opts.TrimGraph)
  89     Res.push_back("-trim-egraph");
  90   if (Opts.VisualizeEGDot)
  91     Res.push_back("-analyzer-viz-egraph-graphviz");
  92   if (Opts.VisualizeEGDot)
  93     Res.push_back("-analyzer-viz-egraph-ubigraph");
  94   if (Opts.EnableExperimentalChecks)
  95     Res.push_back("-analyzer-experimental-checks");
  96   if (Opts.EnableExperimentalInternalChecks)
  97     Res.push_back("-analyzer-experimental-internal-checls");
  98 }
  99
 100 static void CodeGenOptsToArgs(const CodeGenOptions &Opts,
 101                               std::vector<std::string> &Res) {
 102   if (Opts.DebugInfo)
 103     Res.push_back("-g");
 104   if (Opts.DisableLLVMOpts)
 105     Res.push_back("-disable-llvm-optzns");
 106   if (Opts.DisableRedZone)
 107     Res.push_back("-disable-red-zone");
 108   if (!Opts.MergeAllConstants)
 109     Res.push_back("-fno-merge-all-constants");
 110   // NoCommon is only derived.
 111   if (Opts.NoImplicitFloat)
 112     Res.push_back("-no-implicit-float");
 113   if (Opts.OptimizeSize) {
 114     assert(Opts.OptimizationLevel == 2 && "Invalid options!");
 115     Res.push_back("-Os");
 116   } else if (Opts.OptimizationLevel == 0)
 117     Res.push_back("-O" + Opts.OptimizationLevel);
 118   // SimplifyLibCalls is only derived.
 119   // TimePasses is only derived.
 120   // UnitAtATime is unused.
 121   // UnrollLoops is only derived.
 122   // VerifyModule is only derived.
 123   // Inlining is only derived.
 124 }
 125
 126 static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts,
 127                                        std::vector<std::string> &Res) {
 128   if (Opts.IncludeSystemHeaders)
 129     Res.push_back("-sys-header-deps");
 130   if (Opts.UsePhonyTargets)
 131     Res.push_back("-MP");
 132   if (!Opts.OutputFile.empty()) {
 133     Res.push_back("-dependency-file");
 134     Res.push_back(Opts.OutputFile);
 135   }
 136   for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i) {
 137     Res.push_back("-MT");
 138     Res.push_back(Opts.Targets[i]);
 139   }
 140 }
 141
 142 static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts,
 143                                  std::vector<std::string> &Res) {
 144   if (Opts.IgnoreWarnings)
 145     Res.push_back("-w");
 146   if (Opts.NoRewriteMacros)
 147     Res.push_back("-Wno-rewrite-macros");
 148   if (Opts.Pedantic)
 149     Res.push_back("-pedantic");
 150   if (Opts.PedanticErrors)
 151     Res.push_back("-pedantic-errors");
 152   if (!Opts.ShowColumn)
 153     Res.push_back("-fno-show-column");
 154   if (!Opts.ShowLocation)
 155     Res.push_back("-fno-show-source-location");
 156   if (!Opts.ShowCarets)
 157     Res.push_back("-fno-caret-diagnostics");
 158   if (!Opts.ShowFixits)
 159     Res.push_back("-fno-diagnostics-fixit-info");
 160   if (Opts.ShowSourceRanges)
 161     Res.push_back("-fdiagnostics-print-source-range-info");
 162   if (Opts.ShowColors)
 163     Res.push_back("-fcolor-diagnostics");
 164   if (Opts.VerifyDiagnostics)
 165     Res.push_back("-verify");
 166   if (Opts.ShowOptionNames)
 167     Res.push_back("-fdiagnostics-show-option");
 168   if (Opts.MessageLength) {
 169     Res.push_back("-fmessage-length");
 170     Res.push_back(llvm::utostr(Opts.MessageLength));
 171   }
 172   if (!Opts.DumpBuildInformation.empty()) {
 173     Res.push_back("-dump-build-information");
 174     Res.push_back(Opts.DumpBuildInformation);
 175   }
 176   for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i)
 177     Res.push_back("-W" + Opts.Warnings[i]);
 178 }
 179
 180 static const char *getInputKindName(FrontendOptions::InputKind Kind) {
 181   switch (Kind) {
 182   case FrontendOptions::IK_None: break;
 183   case FrontendOptions::IK_AST: return "ast";
 184   case FrontendOptions::IK_Asm: return "assembler-with-cpp";
 185   case FrontendOptions::IK_C: return "c";
 186   case FrontendOptions::IK_CXX: return "c++";
 187   case FrontendOptions::IK_ObjC: return "objective-c";
 188   case FrontendOptions::IK_ObjCXX: return "objective-c++";
 189   case FrontendOptions::IK_OpenCL: return "cl";
 190   case FrontendOptions::IK_PreprocessedC: return "cpp-output";
 191   case FrontendOptions::IK_PreprocessedCXX: return "c++-cpp-output";
 192   case FrontendOptions::IK_PreprocessedObjC: return "objective-c-cpp-output";
 193   case FrontendOptions::IK_PreprocessedObjCXX: return "objective-c++-cpp-output";
 194   }
 195
 196   llvm::llvm_unreachable("Unexpected language kind!");
 197   return 0;
 198 }
 199
 200 static const char *getActionName(frontend::ActionKind Kind) {
 201   switch (Kind) {
 202   case frontend::PluginAction:
 203   case frontend::InheritanceView:
 204     llvm::llvm_unreachable("Invalid kind!");
 205
 206   case frontend::ASTDump:                return "-ast-dump";
 207   case frontend::ASTPrint:               return "-ast-print";
 208   case frontend::ASTPrintXML:            return "-ast-print-xml";
 209   case frontend::ASTView:                return "-ast-view";
 210   case frontend::DumpRawTokens:          return "-dump-raw-tokens";
 211   case frontend::DumpRecordLayouts:      return "-dump-record-layouts";
 212   case frontend::DumpTokens:             return "-dump-tokens";
 213   case frontend::EmitAssembly:           return "-S";
 214   case frontend::EmitBC:                 return "-emit-llvm-bc";
 215   case frontend::EmitHTML:               return "-emit-html";
 216   case frontend::EmitLLVM:               return "-emit-llvm";
 217   case frontend::EmitLLVMOnly:           return "-emit-llvm-only";
 218   case frontend::FixIt:                  return "-fixit";
 219   case frontend::GeneratePCH:            return "-emit-pch";
 220   case frontend::GeneratePTH:            return "-emit-pth";
 221   case frontend::ParseNoop:              return "-parse-noop";
 222   case frontend::ParsePrintCallbacks:    return "-parse-print-callbacks";
 223   case frontend::ParseSyntaxOnly:        return "-fsyntax-only";
 224   case frontend::PrintDeclContext:       return "-print-decl-contexts";
 225   case frontend::PrintPreprocessedInput: return "-E";
 226   case frontend::RewriteBlocks:          return "-rewrite-blocks";
 227   case frontend::RewriteMacros:          return "-rewrite-macros";
 228   case frontend::RewriteObjC:            return "-rewrite-objc";
 229   case frontend::RewriteTest:            return "-rewrite-test";
 230   case frontend::RunAnalysis:            return "-analyze";
 231   case frontend::RunPreprocessorOnly:    return "-Eonly";
 232   }
 233
 234   llvm::llvm_unreachable("Unexpected language kind!");
 235   return 0;
 236 }
 237
 238 static void FrontendOptsToArgs(const FrontendOptions &Opts,
 239                                std::vector<std::string> &Res) {
 240   if (!Opts.DebugCodeCompletionPrinter)
 241     Res.push_back("-code-completion-debug-printer=0");
 242   if (Opts.DisableFree)
 243     Res.push_back("-disable-free");
 244   if (Opts.EmptyInputOnly)
 245     Res.push_back("-empty-input-only");
 246   if (Opts.RelocatablePCH)
 247     Res.push_back("-relocatable-pch");
 248   if (Opts.ShowMacrosInCodeCompletion)
 249     Res.push_back("-code-completion-macros");
 250   if (Opts.ShowStats)
 251     Res.push_back("-stats");
 252   if (Opts.ShowTimers)
 253     Res.push_back("-ftime-report");
 254
 255   bool NeedLang = false;
 256   for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i)
 257     if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].second) !=
 258         Opts.Inputs[i].first)
 259       NeedLang = true;
 260   if (NeedLang) {
 261     Res.push_back("-x");
 262     Res.push_back(getInputKindName(Opts.Inputs[0].first));
 263   }
 264   for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) {
 265     assert((!NeedLang || Opts.Inputs[i].first == Opts.Inputs[0].first) &&
 266            "Unable to represent this input vector!");
 267     Res.push_back(Opts.Inputs[i].second);
 268   }
 269
 270   if (!Opts.OutputFile.empty()) {
 271     Res.push_back("-o");
 272     Res.push_back(Opts.OutputFile);
 273   }
 274   if (!Opts.ViewClassInheritance.empty()) {
 275     Res.push_back("-cxx-inheritance-view");
 276     Res.push_back(Opts.ViewClassInheritance);
 277   }
 278   for (unsigned i = 0, e = Opts.FixItLocations.size(); i != e; ++i) {
 279     Res.push_back("-fixit-at");
 280     Res.push_back(Opts.FixItLocations[i].FileName + ":" +
 281                   llvm::utostr(Opts.FixItLocations[i].Line) + ":" +
 282                   llvm::utostr(Opts.FixItLocations[i].Column));
 283   }
 284   if (!Opts.CodeCompletionAt.FileName.empty()) {
 285     Res.push_back("-code-completion-at");
 286     Res.push_back(Opts.CodeCompletionAt.FileName + ":" +
 287                   llvm::utostr(Opts.CodeCompletionAt.Line) + ":" +
 288                   llvm::utostr(Opts.CodeCompletionAt.Column));
 289   }
 290   if (Opts.ProgramAction != frontend::InheritanceView &&
 291       Opts.ProgramAction != frontend::PluginAction)
 292     Res.push_back(getActionName(Opts.ProgramAction));
 293   if (!Opts.ActionName.empty()) {
 294     Res.push_back("-plugin");
 295     Res.push_back(Opts.ActionName);
 296   }
 297 }
 298
 299 static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts,
 300                                    std::vector<std::string> &Res) {
 301   if (Opts.Sysroot.empty()) {
 302     Res.push_back("-isysroot");
 303     Res.push_back(Opts.Sysroot);
 304   }
 305
 306   /// User specified include entries.
 307   for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) {
 308     const HeaderSearchOptions::Entry &E = Opts.UserEntries[i];
 309     if (E.IsFramework && (E.Group != frontend::Angled || E.IsUserSupplied))
 310       llvm::llvm_report_error("Invalid option set!");
 311     if (E.IsUserSupplied) {
 312       if (E.Group == frontend::After) {
 313         Res.push_back("-idirafter");
 314       } else if (E.Group == frontend::Quoted) {
 315         Res.push_back("-iquoted");
 316       } else if (E.Group == frontend::System) {
 317         Res.push_back("-isystem");
 318       } else {
 319         assert(E.Group == frontend::Angled && "Invalid group!");
 320         Res.push_back(E.IsFramework ? "-F" : "-I");
 321       }
 322     } else {
 323       if (E.Group != frontend::Angled && E.Group != frontend::System)
 324         llvm::llvm_report_error("Invalid option set!");
 325       Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
 326                     "-iwithprefix");
 327     }
 328     Res.push_back(E.Path);
 329   }
 330
 331   if (!Opts.EnvIncPath.empty()) {
 332     // FIXME: Provide an option for this, and move env detection to driver.
 333     llvm::llvm_report_error("Not yet implemented!");
 334   }
 335   if (!Opts.CEnvIncPath.empty()) {
 336     // FIXME: Provide an option for this, and move env detection to driver.
 337     llvm::llvm_report_error("Not yet implemented!");
 338   }
 339   if (!Opts.ObjCEnvIncPath.empty()) {
 340     // FIXME: Provide an option for this, and move env detection to driver.
 341     llvm::llvm_report_error("Not yet implemented!");
 342   }
 343   if (!Opts.CXXEnvIncPath.empty()) {
 344     // FIXME: Provide an option for this, and move env detection to driver.
 345     llvm::llvm_report_error("Not yet implemented!");
 346   }
 347   if (!Opts.ObjCXXEnvIncPath.empty()) {
 348     // FIXME: Provide an option for this, and move env detection to driver.
 349     llvm::llvm_report_error("Not yet implemented!");
 350   }
 351   if (!Opts.BuiltinIncludePath.empty()) {
 352     // FIXME: Provide an option for this, and move to driver.
 353   }
 354   if (!Opts.UseStandardIncludes)
 355     Res.push_back("-nostdinc");
 356   if (Opts.Verbose)
 357     Res.push_back("-v");
 358 }
 359
 360 static void LangOptsToArgs(const LangOptions &Opts,
 361                            std::vector<std::string> &Res) {
 362   LangOptions DefaultLangOpts;
 363
 364   // FIXME: Need to set -std to get all the implicit options.
 365
 366   // FIXME: We want to only pass options relative to the defaults, which
 367   // requires constructing a target. :(
 368   //
 369   // It would be better to push the all target specific choices into the driver,
 370   // so that everything below that was more uniform.
 371
 372   if (Opts.Trigraphs)
 373     Res.push_back("-trigraphs");
 374   // Implicit based on the input kind:
 375   //   AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
 376   // Implicit based on the input language standard:
 377   //   BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
 378   if (Opts.DollarIdents)
 379     Res.push_back("-fdollars-in-identifiers");
 380   if (Opts.Microsoft)
 381     Res.push_back("-fms-extensions=1");
 382   if (Opts.ObjCNonFragileABI)
 383     Res.push_back("-fobjc-nonfragile-abi");
 384   // NoInline is implicit.
 385   if (!Opts.CXXOperatorNames)
 386     Res.push_back("-fno-operator-names");
 387   if (Opts.PascalStrings)
 388     Res.push_back("-fpascal-strings");
 389   if (Opts.WritableStrings)
 390     Res.push_back("-fwritable-strings");
 391   if (!Opts.LaxVectorConversions)
 392     Res.push_back("-fno-lax-vector-conversions");
 393   if (Opts.AltiVec)
 394     Res.push_back("-faltivec");
 395   Res.push_back("-fexceptions");
 396   Res.push_back(Opts.Exceptions ? "1" : "0");
 397   Res.push_back("-frtti");
 398   Res.push_back(Opts.Rtti ? "1" : "0");
 399   if (!Opts.NeXTRuntime)
 400     Res.push_back("-fgnu-runtime");
 401   if (Opts.Freestanding)
 402     Res.push_back("-ffreestanding");
 403   if (Opts.NoBuiltin)
 404     Res.push_back("-fno-builtin");
 405   if (Opts.ThreadsafeStatics)
 406     llvm::llvm_report_error("FIXME: Not yet implemented!");
 407   if (Opts.POSIXThreads)
 408     Res.push_back("-pthread");
 409   if (Opts.Blocks)
 410     Res.push_back("-fblocks=1");
 411   if (Opts.EmitAllDecls)
 412     Res.push_back("-femit-all-decls");
 413   if (!Opts.MathErrno)
 414     Res.push_back("-fmath-errno=0");
 415   if (Opts.OverflowChecking)
 416     Res.push_back("-ftrapv");
 417   if (Opts.HeinousExtensions)
 418     Res.push_back("-fheinous-gnu-extensions");
 419   // Optimize is implicit.
 420   // OptimizeSize is implicit.
 421   if (Opts.Static)
 422     Res.push_back("-static-define");
 423   if (Opts.PICLevel) {
 424     Res.push_back("-pic-level");
 425     Res.push_back(llvm::utostr(Opts.PICLevel));
 426   }
 427   if (Opts.ObjCGCBitmapPrint)
 428     Res.push_back("-print-ivar-layout");
 429   Res.push_back("-faccess-control");
 430   Res.push_back(Opts.AccessControl ? "1" : "0");
 431   Res.push_back("-fsigned-char");
 432   Res.push_back(Opts.CharIsSigned ? "1" : "0");
 433   Res.push_back("-fshort-wchar");
 434   Res.push_back(Opts.ShortWChar ? "1" : "0");
 435   if (!Opts.ElideConstructors)
 436     Res.push_back("-fno-elide-constructors");
 437   if (Opts.getGCMode() != LangOptions::NonGC) {
 438     if (Opts.getGCMode() == LangOptions::HybridGC) {
 439       Res.push_back("-fobjc-gc");
 440     } else {
 441       assert(Opts.getGCMode() == LangOptions::GCOnly && "Invalid GC mode!");
 442       Res.push_back("-fobjc-gc-only");
 443     }
 444   }
 445   if (Opts.getVisibilityMode() != LangOptions::Default) {
 446     Res.push_back("-fvisibility");
 447     if (Opts.getVisibilityMode() == LangOptions::Hidden) {
 448       Res.push_back("default");
 449     } else {
 450       assert(Opts.getVisibilityMode() == LangOptions::Protected &&
 451              "Invalid visibility!");
 452       Res.push_back("protected");
 453     }
 454   }
 455   if (Opts.getStackProtectorMode() != 0) {
 456     Res.push_back("-stack-protector");
 457     Res.push_back(llvm::utostr(Opts.getStackProtectorMode()));
 458   }
 459   if (Opts.getMainFileName()) {
 460     Res.push_back("-main-file-name");
 461     Res.push_back(Opts.getMainFileName());
 462   }
 463   if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) {
 464     Res.push_back("-ftemplate-depth");
 465     Res.push_back(llvm::utostr(Opts.InstantiationDepth));
 466   }
 467   if (Opts.ObjCConstantStringClass) {
 468     Res.push_back("-fconstant-string-class");
 469     Res.push_back(Opts.ObjCConstantStringClass);
 470   }
 471 }
 472
 473 static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
 474                                    std::vector<std::string> &Res) {
 475   for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
 476     Res.push_back((Opts.Macros[i].second ? "-U" : "-D") + Opts.Macros[i].first);
 477   for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
 478     Res.push_back("-include");
 479     Res.push_back(Opts.Includes[i]);
 480   }
 481   for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) {
 482     Res.push_back("-imacros");
 483     Res.push_back(Opts.Includes[i]);
 484   }
 485   if (!Opts.UsePredefines)
 486     Res.push_back("-undef");
 487   if (!Opts.ImplicitPCHInclude.empty()) {
 488     Res.push_back("-implicit-pch-include");
 489     Res.push_back(Opts.ImplicitPCHInclude);
 490   }
 491   if (!Opts.ImplicitPTHInclude.empty()) {
 492     Res.push_back("-implicit-pth-include");
 493     Res.push_back(Opts.ImplicitPTHInclude);
 494   }
 495   if (!Opts.TokenCache.empty()) {
 496     Res.push_back("-token-cache");
 497     Res.push_back(Opts.TokenCache);
 498   }
 499 }
 500
 501 static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
 502                                          std::vector<std::string> &Res) {
 503   if (!Opts.ShowCPP && !Opts.ShowMacros)
 504     llvm::llvm_report_error("Invalid option combination!");
 505
 506   if (Opts.ShowCPP && Opts.ShowMacros)
 507     Res.push_back("-dD");
 508   else if (!Opts.ShowCPP && Opts.ShowMacros)
 509     Res.push_back("-dM");
 510
 511   if (!Opts.ShowLineMarkers)
 512     Res.push_back("-P");
 513   if (Opts.ShowComments)
 514     Res.push_back("-C");
 515   if (Opts.ShowMacroComments)
 516     Res.push_back("-CC");
 517 }
 518
 519 static void TargetOptsToArgs(const TargetOptions &Opts,
 520                              std::vector<std::string> &Res) {
 521   Res.push_back("-triple");
 522   Res.push_back(Opts.Triple);
 523   if (!Opts.CPU.empty()) {
 524     Res.push_back("-target-cpu");
 525     Res.push_back(Opts.CPU);
 526   }
 527   if (!Opts.ABI.empty()) {
 528     Res.push_back("-target-abi");
 529     Res.push_back(Opts.ABI);
 530   }
 531   for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) {
 532     Res.push_back("-target-feature");
 533     Res.push_back(Opts.Features[i]);
 534   }
 535 }
 536
 537 void CompilerInvocation::toArgs(std::vector<std::string> &Res) {
 538   AnalyzerOptsToArgs(getAnalyzerOpts(), Res);
 539   CodeGenOptsToArgs(getCodeGenOpts(), Res);
 540   DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res);
 541   DiagnosticOptsToArgs(getDiagnosticOpts(), Res);
 542   FrontendOptsToArgs(getFrontendOpts(), Res);
 543   HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res);
 544   LangOptsToArgs(getLangOpts(), Res);
 545   PreprocessorOptsToArgs(getPreprocessorOpts(), Res);
 546   PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res);
 547   TargetOptsToArgs(getTargetOpts(), Res);
 548 }