CompilerInvocation.cpp revision 199482 
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  llvm::llvm_report_error("FIXME: Not yet implemented!");
18}
19
20static 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
30static 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
40static 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
50static 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
60static 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
100static 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
126static 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
142static 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
180static 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
200static 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
238static 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
299static 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
360static 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
473static 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
501static 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
519static 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
537void 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}
549