xref: /llvm-project/clang/lib/Frontend/CompilerInvocation.cpp (revision 629f6bb95dc7934e3c96a6728aad7d7ad9ae00ed) 
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   Res.push_back("-fms-extensions");
381   Res.push_back(Opts.Microsoft ? "1" : "0");
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   Res.push_back(Opts.NeXTRuntime ? "-fnext-runtime" : "-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   Res.push_back("-fblocks");
409   Res.push_back(Opts.Blocks ? "1" : "0");
410   if (Opts.EmitAllDecls)
411     Res.push_back("-femit-all-decls");
412   Res.push_back("-fmath-errno");
413   Res.push_back(Opts.MathErrno ? "1" : "0");
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 
472 static 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 
500 static 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 
518 static 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 
536 void 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