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