 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
25.0% |
148 / 593 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
31.4% |
186 / 593 |
| |
|
Line Coverage: |
41.5% |
343 / 827 |
| |
 |
|
 |
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/Driver/Arg.h"
14 : #include "clang/Driver/ArgList.h"
15 : #include "clang/Driver/CC1Options.h"
16 : #include "clang/Driver/DriverDiagnostic.h"
17 : #include "clang/Driver/OptTable.h"
18 : #include "clang/Driver/Option.h"
19 : #include "clang/Frontend/CompilerInvocation.h"
20 : #include "clang/Frontend/LangStandard.h"
21 : #include "clang/Frontend/PCHReader.h"
22 : #include "llvm/ADT/OwningPtr.h"
23 : #include "llvm/ADT/SmallVector.h"
24 : #include "llvm/ADT/StringExtras.h"
25 : #include "llvm/ADT/StringSwitch.h"
26 : #include "llvm/Support/ErrorHandling.h"
27 : #include "llvm/System/Host.h"
28 : #include "llvm/System/Path.h"
29 : using namespace clang;
30 :
31 0: static const char *getAnalysisName(Analyses Kind) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
32 0: switch (Kind) {
33 : default:
34 0: llvm_unreachable("Unknown analysis kind!");
35 : #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE)\
36 : case NAME: return "-" CMDFLAG;
37 : #include "clang/Frontend/Analyses.def"
38 : }
39 : }
40 :
41 0: static const char *getAnalysisStoreName(AnalysisStores Kind) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
42 0: switch (Kind) {
43 : default:
44 0: llvm_unreachable("Unknown analysis store!");
45 : #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
46 : case NAME##Model: return CMDFLAG;
47 : #include "clang/Frontend/Analyses.def"
48 : }
49 : }
50 :
51 0: static const char *getAnalysisConstraintName(AnalysisConstraints Kind) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
52 0: switch (Kind) {
53 : default:
54 0: llvm_unreachable("Unknown analysis constraints!");
55 : #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
56 : case NAME##Model: return CMDFLAG;
57 : #include "clang/Frontend/Analyses.def"
58 : }
59 : }
60 :
61 0: static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
62 0: switch (Kind) {
63 : default:
64 0: llvm_unreachable("Unknown analysis client!");
65 : #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
66 : case PD_##NAME: return CMDFLAG;
67 : #include "clang/Frontend/Analyses.def"
68 : }
69 : }
70 :
71 : //===----------------------------------------------------------------------===//
72 : // Serialization (to args)
73 : //===----------------------------------------------------------------------===//
74 :
75 : static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts,
76 0: std::vector<std::string> &Res) {
0: branch 1 not taken
0: branch 2 not taken
77 0: for (unsigned i = 0, e = Opts.AnalysisList.size(); i != e; ++i)
78 0: Res.push_back(getAnalysisName(Opts.AnalysisList[i]));
0: branch 0 not taken
0: branch 1 not taken
79 0: if (Opts.AnalysisStoreOpt != BasicStoreModel) {
80 0: Res.push_back("-analyzer-store");
81 0: Res.push_back(getAnalysisStoreName(Opts.AnalysisStoreOpt));
82 : }
0: branch 0 not taken
0: branch 1 not taken
83 0: if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {
84 0: Res.push_back("-analyzer-constraints");
85 0: Res.push_back(getAnalysisConstraintName(Opts.AnalysisConstraintsOpt));
86 : }
0: branch 0 not taken
0: branch 1 not taken
87 0: if (Opts.AnalysisDiagOpt != PD_HTML) {
88 0: Res.push_back("-analyzer-output");
89 0: Res.push_back(getAnalysisDiagClientName(Opts.AnalysisDiagOpt));
90 : }
0: branch 1 not taken
0: branch 2 not taken
91 0: if (!Opts.AnalyzeSpecificFunction.empty()) {
92 0: Res.push_back("-analyze-function");
93 0: Res.push_back(Opts.AnalyzeSpecificFunction);
94 : }
0: branch 0 not taken
0: branch 1 not taken
95 0: if (Opts.AnalyzeAll)
96 0: Res.push_back("-analyzer-opt-analyze-headers");
0: branch 0 not taken
0: branch 1 not taken
97 0: if (Opts.AnalyzerDisplayProgress)
98 0: Res.push_back("-analyzer-display-progress");
0: branch 0 not taken
0: branch 1 not taken
99 0: if (Opts.AnalyzeNestedBlocks)
100 0: Res.push_back("-analyzer-opt-analyze-nested-blocks");
0: branch 0 not taken
0: branch 1 not taken
101 0: if (Opts.EagerlyAssume)
102 0: Res.push_back("-analyzer-eagerly-assume");
0: branch 0 not taken
0: branch 1 not taken
103 0: if (!Opts.PurgeDead)
104 0: Res.push_back("-analyzer-no-purge-dead");
0: branch 0 not taken
0: branch 1 not taken
105 0: if (Opts.TrimGraph)
106 0: Res.push_back("-trim-egraph");
0: branch 0 not taken
0: branch 1 not taken
107 0: if (Opts.VisualizeEGDot)
108 0: Res.push_back("-analyzer-viz-egraph-graphviz");
0: branch 0 not taken
0: branch 1 not taken
109 0: if (Opts.VisualizeEGDot)
110 0: Res.push_back("-analyzer-viz-egraph-ubigraph");
0: branch 0 not taken
0: branch 1 not taken
111 0: if (Opts.EnableExperimentalChecks)
112 0: Res.push_back("-analyzer-experimental-checks");
0: branch 0 not taken
0: branch 1 not taken
113 0: if (Opts.EnableExperimentalInternalChecks)
114 0: Res.push_back("-analyzer-experimental-internal-checks");
115 0: }
116 :
117 : static void CodeGenOptsToArgs(const CodeGenOptions &Opts,
118 0: std::vector<std::string> &Res) {
0: branch 0 not taken
0: branch 1 not taken
119 0: if (Opts.DebugInfo)
120 0: Res.push_back("-g");
0: branch 0 not taken
0: branch 1 not taken
121 0: if (Opts.DisableLLVMOpts)
122 0: Res.push_back("-disable-llvm-optzns");
0: branch 0 not taken
0: branch 1 not taken
123 0: if (Opts.DisableRedZone)
124 0: Res.push_back("-disable-red-zone");
0: branch 1 not taken
0: branch 2 not taken
125 0: if (!Opts.DwarfDebugFlags.empty()) {
126 0: Res.push_back("-dwarf-debug-flags");
127 0: Res.push_back(Opts.DwarfDebugFlags);
128 : }
0: branch 0 not taken
0: branch 1 not taken
129 0: if (!Opts.MergeAllConstants)
130 0: Res.push_back("-fno-merge-all-constants");
0: branch 0 not taken
0: branch 1 not taken
131 0: if (Opts.NoCommon)
132 0: Res.push_back("-fno-common");
0: branch 0 not taken
0: branch 1 not taken
133 0: if (Opts.NoImplicitFloat)
134 0: Res.push_back("-no-implicit-float");
0: branch 0 not taken
0: branch 1 not taken
135 0: if (Opts.OptimizeSize) {
0: branch 0 not taken
0: branch 1 not taken
136 0: assert(Opts.OptimizationLevel == 2 && "Invalid options!");
137 0: Res.push_back("-Os");
0: branch 0 not taken
0: branch 1 not taken
138 0: } else if (Opts.OptimizationLevel != 0)
139 0: Res.push_back("-O" + llvm::utostr(Opts.OptimizationLevel));
0: branch 1 not taken
0: branch 2 not taken
140 0: if (!Opts.MainFileName.empty()) {
141 0: Res.push_back("-main-file-name");
142 0: Res.push_back(Opts.MainFileName);
143 : }
144 : // SimplifyLibCalls is only derived.
145 : // TimePasses is only derived.
146 : // UnitAtATime is unused.
147 : // UnrollLoops is only derived.
148 : // VerifyModule is only derived.
149 : // Inlining is only derived.
150 :
0: branch 0 not taken
0: branch 1 not taken
151 0: if (Opts.AsmVerbose)
152 0: Res.push_back("-masm-verbose");
0: branch 1 not taken
0: branch 2 not taken
153 0: if (!Opts.CodeModel.empty()) {
154 0: Res.push_back("-mcode-model");
155 0: Res.push_back(Opts.CodeModel);
156 : }
0: branch 1 not taken
0: branch 2 not taken
157 0: if (!Opts.DebugPass.empty()) {
158 0: Res.push_back("-mdebug-pass");
159 0: Res.push_back(Opts.DebugPass);
160 : }
0: branch 0 not taken
0: branch 1 not taken
161 0: if (Opts.DisableFPElim)
162 0: Res.push_back("-mdisable-fp-elim");
0: branch 1 not taken
0: branch 2 not taken
163 0: if (!Opts.FloatABI.empty()) {
164 0: Res.push_back("-mfloat-abi");
165 0: Res.push_back(Opts.FloatABI);
166 : }
0: branch 1 not taken
0: branch 2 not taken
167 0: if (!Opts.LimitFloatPrecision.empty()) {
168 0: Res.push_back("-mlimit-float-precision");
169 0: Res.push_back(Opts.LimitFloatPrecision);
170 : }
0: branch 0 not taken
0: branch 1 not taken
171 0: if (Opts.NoZeroInitializedInBSS)
172 0: Res.push_back("-mno-zero-initialized-bss");
0: branch 0 not taken
0: branch 1 not taken
173 0: if (Opts.ObjCLegacyDispatch)
174 0: Res.push_back("-fobjc-legacy-dispatch");
0: branch 0 not taken
0: branch 1 not taken
175 0: if (Opts.SoftFloat)
176 0: Res.push_back("-msoft-float");
0: branch 0 not taken
0: branch 1 not taken
177 0: if (Opts.UnwindTables)
178 0: Res.push_back("-munwind-tables");
0: branch 1 not taken
0: branch 2 not taken
179 0: if (Opts.RelocationModel != "pic") {
180 0: Res.push_back("-mrelocation-model");
181 0: Res.push_back(Opts.RelocationModel);
182 : }
183 0: }
184 :
185 : static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts,
186 0: std::vector<std::string> &Res) {
0: branch 0 not taken
0: branch 1 not taken
187 0: if (Opts.IncludeSystemHeaders)
188 0: Res.push_back("-sys-header-deps");
0: branch 0 not taken
0: branch 1 not taken
189 0: if (Opts.UsePhonyTargets)
190 0: Res.push_back("-MP");
0: branch 1 not taken
0: branch 2 not taken
191 0: if (!Opts.OutputFile.empty()) {
192 0: Res.push_back("-dependency-file");
193 0: Res.push_back(Opts.OutputFile);
194 : }
0: branch 1 not taken
0: branch 2 not taken
195 0: for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i) {
196 0: Res.push_back("-MT");
197 0: Res.push_back(Opts.Targets[i]);
198 : }
199 0: }
200 :
201 : static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts,
202 0: std::vector<std::string> &Res) {
0: branch 0 not taken
0: branch 1 not taken
203 0: if (Opts.IgnoreWarnings)
204 0: Res.push_back("-w");
0: branch 0 not taken
0: branch 1 not taken
205 0: if (Opts.NoRewriteMacros)
206 0: Res.push_back("-Wno-rewrite-macros");
0: branch 0 not taken
0: branch 1 not taken
207 0: if (Opts.Pedantic)
208 0: Res.push_back("-pedantic");
0: branch 0 not taken
0: branch 1 not taken
209 0: if (Opts.PedanticErrors)
210 0: Res.push_back("-pedantic-errors");
0: branch 0 not taken
0: branch 1 not taken
211 0: if (!Opts.ShowColumn)
212 0: Res.push_back("-fno-show-column");
0: branch 0 not taken
0: branch 1 not taken
213 0: if (!Opts.ShowLocation)
214 0: Res.push_back("-fno-show-source-location");
0: branch 0 not taken
0: branch 1 not taken
215 0: if (!Opts.ShowCarets)
216 0: Res.push_back("-fno-caret-diagnostics");
0: branch 0 not taken
0: branch 1 not taken
217 0: if (!Opts.ShowFixits)
218 0: Res.push_back("-fno-diagnostics-fixit-info");
0: branch 0 not taken
0: branch 1 not taken
219 0: if (Opts.ShowSourceRanges)
220 0: Res.push_back("-fdiagnostics-print-source-range-info");
0: branch 0 not taken
0: branch 1 not taken
221 0: if (Opts.ShowColors)
222 0: Res.push_back("-fcolor-diagnostics");
0: branch 0 not taken
0: branch 1 not taken
223 0: if (Opts.VerifyDiagnostics)
224 0: Res.push_back("-verify");
0: branch 0 not taken
0: branch 1 not taken
225 0: if (Opts.BinaryOutput)
226 0: Res.push_back("-fdiagnostics-binary");
0: branch 0 not taken
0: branch 1 not taken
227 0: if (Opts.ShowOptionNames)
228 0: Res.push_back("-fdiagnostics-show-option");
0: branch 0 not taken
0: branch 1 not taken
229 0: if (Opts.TabStop != DiagnosticOptions::DefaultTabStop) {
230 0: Res.push_back("-ftabstop");
231 0: Res.push_back(llvm::utostr(Opts.TabStop));
232 : }
0: branch 0 not taken
0: branch 1 not taken
233 0: if (Opts.MessageLength) {
234 0: Res.push_back("-fmessage-length");
235 0: Res.push_back(llvm::utostr(Opts.MessageLength));
236 : }
0: branch 1 not taken
0: branch 2 not taken
237 0: if (!Opts.DumpBuildInformation.empty()) {
238 0: Res.push_back("-dump-build-information");
239 0: Res.push_back(Opts.DumpBuildInformation);
240 : }
0: branch 1 not taken
0: branch 2 not taken
241 0: for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i)
242 0: Res.push_back("-W" + Opts.Warnings[i]);
243 0: }
244 :
245 0: static const char *getInputKindName(FrontendOptions::InputKind Kind) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
246 0: switch (Kind) {
247 0: case FrontendOptions::IK_None: break;
248 0: case FrontendOptions::IK_AST: return "ast";
249 0: case FrontendOptions::IK_Asm: return "assembler-with-cpp";
250 0: case FrontendOptions::IK_C: return "c";
251 0: case FrontendOptions::IK_CXX: return "c++";
252 0: case FrontendOptions::IK_ObjC: return "objective-c";
253 0: case FrontendOptions::IK_ObjCXX: return "objective-c++";
254 0: case FrontendOptions::IK_OpenCL: return "cl";
255 0: case FrontendOptions::IK_PreprocessedC: return "cpp-output";
256 0: case FrontendOptions::IK_PreprocessedCXX: return "c++-cpp-output";
257 0: case FrontendOptions::IK_PreprocessedObjC: return "objective-c-cpp-output";
258 0: case FrontendOptions::IK_PreprocessedObjCXX:return "objective-c++-cpp-output";
259 : }
260 :
261 0: llvm_unreachable("Unexpected language kind!");
262 : return 0;
263 : }
264 :
265 0: static const char *getActionName(frontend::ActionKind Kind) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 15 not taken
0: branch 16 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 20 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 23 not taken
0: branch 24 not taken
0: branch 25 not taken
0: branch 26 not taken
0: branch 27 not taken
266 0: switch (Kind) {
267 : case frontend::PluginAction:
268 : case frontend::InheritanceView:
269 0: llvm_unreachable("Invalid kind!");
270 :
271 0: case frontend::ASTDump: return "-ast-dump";
272 0: case frontend::ASTPrint: return "-ast-print";
273 0: case frontend::ASTPrintXML: return "-ast-print-xml";
274 0: case frontend::ASTView: return "-ast-view";
275 0: case frontend::DumpRawTokens: return "-dump-raw-tokens";
276 0: case frontend::DumpRecordLayouts: return "-dump-record-layouts";
277 0: case frontend::DumpTokens: return "-dump-tokens";
278 0: case frontend::EmitAssembly: return "-S";
279 0: case frontend::EmitBC: return "-emit-llvm-bc";
280 0: case frontend::EmitHTML: return "-emit-html";
281 0: case frontend::EmitLLVM: return "-emit-llvm";
282 0: case frontend::EmitLLVMOnly: return "-emit-llvm-only";
283 0: case frontend::EmitObj: return "-emit-obj";
284 0: case frontend::FixIt: return "-fixit";
285 0: case frontend::GeneratePCH: return "-emit-pch";
286 0: case frontend::GeneratePTH: return "-emit-pth";
287 0: case frontend::ParseNoop: return "-parse-noop";
288 0: case frontend::ParsePrintCallbacks: return "-parse-print-callbacks";
289 0: case frontend::ParseSyntaxOnly: return "-fsyntax-only";
290 0: case frontend::PrintDeclContext: return "-print-decl-contexts";
291 0: case frontend::PrintPreprocessedInput: return "-E";
292 0: case frontend::RewriteMacros: return "-rewrite-macros";
293 0: case frontend::RewriteObjC: return "-rewrite-objc";
294 0: case frontend::RewriteTest: return "-rewrite-test";
295 0: case frontend::RunAnalysis: return "-analyze";
296 0: case frontend::RunPreprocessorOnly: return "-Eonly";
297 : }
298 :
299 0: llvm_unreachable("Unexpected language kind!");
300 : return 0;
301 : }
302 :
303 : static void FrontendOptsToArgs(const FrontendOptions &Opts,
304 0: std::vector<std::string> &Res) {
0: branch 0 not taken
0: branch 1 not taken
305 0: if (!Opts.DebugCodeCompletionPrinter)
306 0: Res.push_back("-no-code-completion-debug-printer");
0: branch 0 not taken
0: branch 1 not taken
307 0: if (Opts.DisableFree)
308 0: Res.push_back("-disable-free");
0: branch 0 not taken
0: branch 1 not taken
309 0: if (Opts.EmptyInputOnly)
310 0: Res.push_back("-empty-input-only");
0: branch 0 not taken
0: branch 1 not taken
311 0: if (Opts.RelocatablePCH)
312 0: Res.push_back("-relocatable-pch");
0: branch 0 not taken
0: branch 1 not taken
313 0: if (Opts.ShowHelp)
314 0: Res.push_back("-help");
0: branch 0 not taken
0: branch 1 not taken
315 0: if (Opts.ShowMacrosInCodeCompletion)
316 0: Res.push_back("-code-completion-macros");
0: branch 0 not taken
0: branch 1 not taken
317 0: if (Opts.ShowStats)
318 0: Res.push_back("-print-stats");
0: branch 0 not taken
0: branch 1 not taken
319 0: if (Opts.ShowTimers)
320 0: Res.push_back("-ftime-report");
0: branch 0 not taken
0: branch 1 not taken
321 0: if (Opts.ShowVersion)
322 0: Res.push_back("-version");
323 :
324 0: bool NeedLang = false;
0: branch 1 not taken
0: branch 2 not taken
325 0: for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i)
0: branch 4 not taken
0: branch 5 not taken
326 0: if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].second) !=
327 : Opts.Inputs[i].first)
328 0: NeedLang = true;
0: branch 0 not taken
0: branch 1 not taken
329 0: if (NeedLang) {
330 0: Res.push_back("-x");
331 0: Res.push_back(getInputKindName(Opts.Inputs[0].first));
332 : }
0: branch 1 not taken
0: branch 2 not taken
333 0: for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) {
334 : assert((!NeedLang || Opts.Inputs[i].first == Opts.Inputs[0].first) &&
0: branch 0 not taken
0: branch 1 not taken
0: branch 4 not taken
0: branch 5 not taken
335 0: "Unable to represent this input vector!");
336 0: Res.push_back(Opts.Inputs[i].second);
337 : }
338 :
0: branch 1 not taken
0: branch 2 not taken
339 0: if (!Opts.OutputFile.empty()) {
340 0: Res.push_back("-o");
341 0: Res.push_back(Opts.OutputFile);
342 : }
0: branch 1 not taken
0: branch 2 not taken
343 0: if (!Opts.ViewClassInheritance.empty()) {
344 0: Res.push_back("-cxx-inheritance-view");
345 0: Res.push_back(Opts.ViewClassInheritance);
346 : }
0: branch 1 not taken
0: branch 2 not taken
347 0: for (unsigned i = 0, e = Opts.FixItLocations.size(); i != e; ++i) {
348 0: Res.push_back("-fixit-at");
349 : Res.push_back(Opts.FixItLocations[i].FileName + ":" +
350 : llvm::utostr(Opts.FixItLocations[i].Line) + ":" +
351 0: llvm::utostr(Opts.FixItLocations[i].Column));
352 : }
0: branch 1 not taken
0: branch 2 not taken
353 0: if (!Opts.CodeCompletionAt.FileName.empty()) {
354 0: Res.push_back("-code-completion-at");
355 : Res.push_back(Opts.CodeCompletionAt.FileName + ":" +
356 : llvm::utostr(Opts.CodeCompletionAt.Line) + ":" +
357 0: llvm::utostr(Opts.CodeCompletionAt.Column));
358 : }
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
359 0: if (Opts.ProgramAction != frontend::InheritanceView &&
360 : Opts.ProgramAction != frontend::PluginAction)
361 0: Res.push_back(getActionName(Opts.ProgramAction));
0: branch 1 not taken
0: branch 2 not taken
362 0: if (!Opts.ActionName.empty()) {
363 0: Res.push_back("-plugin");
364 0: Res.push_back(Opts.ActionName);
365 : }
0: branch 1 not taken
0: branch 2 not taken
366 0: for (unsigned i = 0, e = Opts.Plugins.size(); i != e; ++i) {
367 0: Res.push_back("-load");
368 0: Res.push_back(Opts.Plugins[i]);
369 : }
0: branch 1 not taken
0: branch 2 not taken
370 0: for (unsigned i = 0, e = Opts.ASTMergeFiles.size(); i != e; ++i) {
371 0: Res.push_back("-ast-merge");
372 0: Res.push_back(Opts.ASTMergeFiles[i]);
373 : }
374 0: }
375 :
376 : static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts,
377 0: std::vector<std::string> &Res) {
0: branch 1 not taken
0: branch 2 not taken
378 0: if (Opts.Sysroot != "/") {
379 0: Res.push_back("-isysroot");
380 0: Res.push_back(Opts.Sysroot);
381 : }
382 :
383 : /// User specified include entries.
0: branch 1 not taken
0: branch 2 not taken
384 0: for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) {
385 0: const HeaderSearchOptions::Entry &E = Opts.UserEntries[i];
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
386 0: if (E.IsFramework && (E.Group != frontend::Angled || !E.IsUserSupplied))
387 0: llvm::llvm_report_error("Invalid option set!");
0: branch 0 not taken
0: branch 1 not taken
388 0: if (E.IsUserSupplied) {
0: branch 0 not taken
0: branch 1 not taken
389 0: if (E.Group == frontend::After) {
390 0: Res.push_back("-idirafter");
0: branch 0 not taken
0: branch 1 not taken
391 0: } else if (E.Group == frontend::Quoted) {
392 0: Res.push_back("-iquote");
0: branch 0 not taken
0: branch 1 not taken
393 0: } else if (E.Group == frontend::System) {
394 0: Res.push_back("-isystem");
395 : } else {
0: branch 0 not taken
0: branch 1 not taken
396 0: assert(E.Group == frontend::Angled && "Invalid group!");
0: branch 1 not taken
0: branch 2 not taken
397 0: Res.push_back(E.IsFramework ? "-F" : "-I");
398 : }
399 : } else {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
400 0: if (E.Group != frontend::Angled && E.Group != frontend::System)
401 0: llvm::llvm_report_error("Invalid option set!");
402 : Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
0: branch 1 not taken
0: branch 2 not taken
403 0: "-iwithprefix");
404 : }
405 0: Res.push_back(E.Path);
406 : }
407 :
0: branch 1 not taken
0: branch 2 not taken
408 0: if (!Opts.EnvIncPath.empty()) {
409 : // FIXME: Provide an option for this, and move env detection to driver.
410 0: llvm::llvm_report_error("Not yet implemented!");
411 : }
0: branch 1 not taken
0: branch 2 not taken
412 0: if (!Opts.CEnvIncPath.empty()) {
413 : // FIXME: Provide an option for this, and move env detection to driver.
414 0: llvm::llvm_report_error("Not yet implemented!");
415 : }
0: branch 1 not taken
0: branch 2 not taken
416 0: if (!Opts.ObjCEnvIncPath.empty()) {
417 : // FIXME: Provide an option for this, and move env detection to driver.
418 0: llvm::llvm_report_error("Not yet implemented!");
419 : }
0: branch 1 not taken
0: branch 2 not taken
420 0: if (!Opts.CXXEnvIncPath.empty()) {
421 : // FIXME: Provide an option for this, and move env detection to driver.
422 0: llvm::llvm_report_error("Not yet implemented!");
423 : }
0: branch 1 not taken
0: branch 2 not taken
424 0: if (!Opts.ObjCXXEnvIncPath.empty()) {
425 : // FIXME: Provide an option for this, and move env detection to driver.
426 0: llvm::llvm_report_error("Not yet implemented!");
427 : }
0: branch 1 not taken
0: branch 2 not taken
428 0: if (!Opts.ResourceDir.empty()) {
429 0: Res.push_back("-resource-dir");
430 0: Res.push_back(Opts.ResourceDir);
431 : }
0: branch 0 not taken
0: branch 1 not taken
432 0: if (!Opts.UseStandardIncludes)
433 0: Res.push_back("-nostdinc");
0: branch 0 not taken
0: branch 1 not taken
434 0: if (Opts.Verbose)
435 0: Res.push_back("-v");
436 0: }
437 :
438 : static void LangOptsToArgs(const LangOptions &Opts,
439 0: std::vector<std::string> &Res) {
440 0: LangOptions DefaultLangOpts;
441 :
442 : // FIXME: Need to set -std to get all the implicit options.
443 :
444 : // FIXME: We want to only pass options relative to the defaults, which
445 : // requires constructing a target. :(
446 : //
447 : // It would be better to push the all target specific choices into the driver,
448 : // so that everything below that was more uniform.
449 :
0: branch 0 not taken
0: branch 1 not taken
450 0: if (Opts.Trigraphs)
451 0: Res.push_back("-trigraphs");
452 : // Implicit based on the input kind:
453 : // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
454 : // Implicit based on the input language standard:
455 : // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
0: branch 0 not taken
0: branch 1 not taken
456 0: if (Opts.DollarIdents)
457 0: Res.push_back("-fdollars-in-identifiers");
0: branch 0 not taken
0: branch 1 not taken
458 0: if (Opts.Microsoft)
459 0: Res.push_back("-fms-extensions");
0: branch 0 not taken
0: branch 1 not taken
460 0: if (Opts.ObjCNonFragileABI)
461 0: Res.push_back("-fobjc-nonfragile-abi");
0: branch 0 not taken
0: branch 1 not taken
462 0: if (Opts.ObjCNonFragileABI2)
463 0: Res.push_back("-fobjc-nonfragile-abi2");
464 : // NoInline is implicit.
0: branch 0 not taken
0: branch 1 not taken
465 0: if (!Opts.CXXOperatorNames)
466 0: Res.push_back("-fno-operator-names");
0: branch 0 not taken
0: branch 1 not taken
467 0: if (Opts.PascalStrings)
468 0: Res.push_back("-fpascal-strings");
0: branch 0 not taken
0: branch 1 not taken
469 0: if (Opts.CatchUndefined)
470 0: Res.push_back("-fcatch-undefined-behavior");
0: branch 0 not taken
0: branch 1 not taken
471 0: if (Opts.WritableStrings)
472 0: Res.push_back("-fwritable-strings");
0: branch 0 not taken
0: branch 1 not taken
473 0: if (!Opts.LaxVectorConversions)
474 0: Res.push_back("-fno-lax-vector-conversions");
0: branch 0 not taken
0: branch 1 not taken
475 0: if (Opts.AltiVec)
476 0: Res.push_back("-faltivec");
0: branch 0 not taken
0: branch 1 not taken
477 0: if (Opts.Exceptions)
478 0: Res.push_back("-fexceptions");
0: branch 0 not taken
0: branch 1 not taken
479 0: if (!Opts.RTTI)
480 0: Res.push_back("-fno-rtti");
0: branch 0 not taken
0: branch 1 not taken
481 0: if (!Opts.NeXTRuntime)
482 0: Res.push_back("-fgnu-runtime");
0: branch 0 not taken
0: branch 1 not taken
483 0: if (Opts.Freestanding)
484 0: Res.push_back("-ffreestanding");
0: branch 0 not taken
0: branch 1 not taken
485 0: if (Opts.NoBuiltin)
486 0: Res.push_back("-fno-builtin");
0: branch 0 not taken
0: branch 1 not taken
487 0: if (!Opts.AssumeSaneOperatorNew)
488 0: Res.push_back("-fno-assume-sane-operator-new");
0: branch 0 not taken
0: branch 1 not taken
489 0: if (!Opts.ThreadsafeStatics)
490 0: Res.push_back("-fno-threadsafe-statics");
0: branch 0 not taken
0: branch 1 not taken
491 0: if (Opts.POSIXThreads)
492 0: Res.push_back("-pthread");
0: branch 0 not taken
0: branch 1 not taken
493 0: if (Opts.Blocks)
494 0: Res.push_back("-fblocks");
0: branch 0 not taken
0: branch 1 not taken
495 0: if (Opts.EmitAllDecls)
496 0: Res.push_back("-femit-all-decls");
0: branch 0 not taken
0: branch 1 not taken
497 0: if (Opts.MathErrno)
498 0: Res.push_back("-fmath-errno");
0: branch 0 not taken
0: branch 1 not taken
499 0: if (Opts.OverflowChecking)
500 0: Res.push_back("-ftrapv");
0: branch 0 not taken
0: branch 1 not taken
501 0: if (Opts.HeinousExtensions)
502 0: Res.push_back("-fheinous-gnu-extensions");
503 : // Optimize is implicit.
504 : // OptimizeSize is implicit.
0: branch 0 not taken
0: branch 1 not taken
505 0: if (Opts.Static)
506 0: Res.push_back("-static-define");
0: branch 0 not taken
0: branch 1 not taken
507 0: if (Opts.PICLevel) {
508 0: Res.push_back("-pic-level");
509 0: Res.push_back(llvm::utostr(Opts.PICLevel));
510 : }
0: branch 0 not taken
0: branch 1 not taken
511 0: if (Opts.ObjCGCBitmapPrint)
512 0: Res.push_back("-print-ivar-layout");
513 : // FIXME: Don't forget to update when the default changes!
0: branch 0 not taken
0: branch 1 not taken
514 0: if (Opts.AccessControl)
515 0: Res.push_back("-faccess-control");
0: branch 0 not taken
0: branch 1 not taken
516 0: if (!Opts.CharIsSigned)
517 0: Res.push_back("-fno-signed-char");
0: branch 0 not taken
0: branch 1 not taken
518 0: if (Opts.ShortWChar)
519 0: Res.push_back("-fshort-wchar");
0: branch 0 not taken
0: branch 1 not taken
520 0: if (!Opts.ElideConstructors)
521 0: Res.push_back("-fno-elide-constructors");
0: branch 1 not taken
0: branch 2 not taken
522 0: if (Opts.getGCMode() != LangOptions::NonGC) {
0: branch 1 not taken
0: branch 2 not taken
523 0: if (Opts.getGCMode() == LangOptions::HybridGC) {
524 0: Res.push_back("-fobjc-gc");
525 : } else {
0: branch 1 not taken
0: branch 2 not taken
526 0: assert(Opts.getGCMode() == LangOptions::GCOnly && "Invalid GC mode!");
527 0: Res.push_back("-fobjc-gc-only");
528 : }
529 : }
0: branch 1 not taken
0: branch 2 not taken
530 0: if (Opts.getVisibilityMode() != LangOptions::Default) {
531 0: Res.push_back("-fvisibility");
0: branch 1 not taken
0: branch 2 not taken
532 0: if (Opts.getVisibilityMode() == LangOptions::Hidden) {
533 0: Res.push_back("hidden");
534 : } else {
535 : assert(Opts.getVisibilityMode() == LangOptions::Protected &&
0: branch 1 not taken
0: branch 2 not taken
536 0: "Invalid visibility!");
537 0: Res.push_back("protected");
538 : }
539 : }
0: branch 1 not taken
0: branch 2 not taken
540 0: if (Opts.getStackProtectorMode() != 0) {
541 0: Res.push_back("-stack-protector");
542 0: Res.push_back(llvm::utostr(Opts.getStackProtectorMode()));
543 : }
0: branch 0 not taken
0: branch 1 not taken
544 0: if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) {
545 0: Res.push_back("-ftemplate-depth");
546 0: Res.push_back(llvm::utostr(Opts.InstantiationDepth));
547 : }
0: branch 1 not taken
0: branch 2 not taken
548 0: if (!Opts.ObjCConstantStringClass.empty()) {
549 0: Res.push_back("-fconstant-string-class");
550 0: Res.push_back(Opts.ObjCConstantStringClass);
551 0: }
552 0: }
553 :
554 : static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
555 0: std::vector<std::string> &Res) {
0: branch 1 not taken
0: branch 2 not taken
556 0: for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
557 : Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") +
0: branch 3 not taken
0: branch 4 not taken
558 0: Opts.Macros[i].first);
0: branch 1 not taken
0: branch 2 not taken
559 0: for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
560 : // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
561 0: Res.push_back("-include");
562 0: Res.push_back(Opts.Includes[i]);
563 : }
0: branch 1 not taken
0: branch 2 not taken
564 0: for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) {
565 0: Res.push_back("-imacros");
566 0: Res.push_back(Opts.MacroIncludes[i]);
567 : }
0: branch 0 not taken
0: branch 1 not taken
568 0: if (!Opts.UsePredefines)
569 0: Res.push_back("-undef");
0: branch 1 not taken
0: branch 2 not taken
570 0: if (!Opts.ImplicitPCHInclude.empty()) {
571 0: Res.push_back("-include-pch");
572 0: Res.push_back(Opts.ImplicitPCHInclude);
573 : }
0: branch 1 not taken
0: branch 2 not taken
574 0: if (!Opts.ImplicitPTHInclude.empty()) {
575 0: Res.push_back("-include-pth");
576 0: Res.push_back(Opts.ImplicitPTHInclude);
577 : }
0: branch 1 not taken
0: branch 2 not taken
578 0: if (!Opts.TokenCache.empty()) {
0: branch 1 not taken
0: branch 2 not taken
579 0: if (Opts.ImplicitPTHInclude.empty()) {
580 0: Res.push_back("-token-cache");
581 0: Res.push_back(Opts.TokenCache);
582 : } else
583 : assert(Opts.ImplicitPTHInclude == Opts.TokenCache &&
0: branch 1 not taken
0: branch 2 not taken
584 0: "Unsupported option combination!");
585 : }
0: branch 1 not taken
0: branch 2 not taken
586 0: for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) {
587 0: Res.push_back("-remap-file");
588 : Res.push_back(Opts.RemappedFiles[i].first + ";" +
589 0: Opts.RemappedFiles[i].second);
590 : }
591 0: }
592 :
593 : static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
594 0: std::vector<std::string> &Res) {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
595 0: if (!Opts.ShowCPP && !Opts.ShowMacros)
596 0: llvm::llvm_report_error("Invalid option combination!");
597 :
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
598 0: if (Opts.ShowCPP && Opts.ShowMacros)
599 0: Res.push_back("-dD");
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
600 0: else if (!Opts.ShowCPP && Opts.ShowMacros)
601 0: Res.push_back("-dM");
602 :
0: branch 0 not taken
0: branch 1 not taken
603 0: if (!Opts.ShowLineMarkers)
604 0: Res.push_back("-P");
0: branch 0 not taken
0: branch 1 not taken
605 0: if (Opts.ShowComments)
606 0: Res.push_back("-C");
0: branch 0 not taken
0: branch 1 not taken
607 0: if (Opts.ShowMacroComments)
608 0: Res.push_back("-CC");
609 0: }
610 :
611 : static void TargetOptsToArgs(const TargetOptions &Opts,
612 0: std::vector<std::string> &Res) {
613 0: Res.push_back("-triple");
614 0: Res.push_back(Opts.Triple);
0: branch 1 not taken
0: branch 2 not taken
615 0: if (!Opts.CPU.empty()) {
616 0: Res.push_back("-target-cpu");
617 0: Res.push_back(Opts.CPU);
618 : }
0: branch 1 not taken
0: branch 2 not taken
619 0: if (!Opts.ABI.empty()) {
620 0: Res.push_back("-target-abi");
621 0: Res.push_back(Opts.ABI);
622 : }
0: branch 1 not taken
0: branch 2 not taken
623 0: for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) {
624 0: Res.push_back("-target-feature");
625 0: Res.push_back(Opts.Features[i]);
626 : }
627 0: }
628 :
629 0: void CompilerInvocation::toArgs(std::vector<std::string> &Res) {
630 0: AnalyzerOptsToArgs(getAnalyzerOpts(), Res);
631 0: CodeGenOptsToArgs(getCodeGenOpts(), Res);
632 0: DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res);
633 0: DiagnosticOptsToArgs(getDiagnosticOpts(), Res);
634 0: FrontendOptsToArgs(getFrontendOpts(), Res);
635 0: HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res);
636 0: LangOptsToArgs(getLangOpts(), Res);
637 0: PreprocessorOptsToArgs(getPreprocessorOpts(), Res);
638 0: PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res);
639 0: TargetOptsToArgs(getTargetOpts(), Res);
640 0: }
641 :
642 : //===----------------------------------------------------------------------===//
643 : // Deserialization (to args)
644 : //===----------------------------------------------------------------------===//
645 :
646 : using namespace clang::driver;
647 : using namespace clang::driver::cc1options;
648 :
649 : static llvm::StringRef getLastArgValue(ArgList &Args, cc1options::ID ID,
650 52979: llvm::StringRef Default = "") {
2001: branch 2 taken
50978: branch 3 taken
651 52979: if (Arg *A = Args.getLastArg(ID))
652 2001: return A->getValue(Args);
653 50978: return Default;
654 : }
655 :
656 : static int getLastArgIntValue(ArgList &Args, cc1options::ID ID,
657 17647: int Default, Diagnostic &Diags) {
658 17647: Arg *A = Args.getLastArg(ID);
17397: branch 0 taken
250: branch 1 taken
659 17647: if (!A)
660 17397: return Default;
661 :
662 250: int Res = Default;
0: branch 3 not taken
250: branch 4 taken
663 250: if (llvm::StringRef(A->getValue(Args)).getAsInteger(10, Res))
664 : Diags.Report(diag::err_drv_invalid_int_value)
665 0: << A->getAsString(Args) << A->getValue(Args);
666 :
667 250: return Res;
668 : }
669 :
670 : static std::vector<std::string>
671 17661: getAllArgValues(ArgList &Args, cc1options::ID ID) {
672 17661: llvm::SmallVector<const char *, 16> Values;
673 17661: Args.AddAllArgValues(Values, ID);
674 17661: return std::vector<std::string>(Values.begin(), Values.end());
675 : }
676 :
677 : //
678 :
679 : static void ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
680 2523: Diagnostic &Diags) {
681 : using namespace cc1options;
682 :
683 2523: Opts.AnalysisList.clear();
684 : #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) \
685 : if (Args.hasArg(OPT_analysis_##NAME)) Opts.AnalysisList.push_back(NAME);
686 : #include "clang/Frontend/Analyses.def"
687 :
174: branch 2 taken
2349: branch 3 taken
688 2523: if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
689 174: llvm::StringRef Name = A->getValue(Args);
690 : AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
691 : #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
692 : .Case(CMDFLAG, NAME##Model)
693 : #include "clang/Frontend/Analyses.def"
694 174: .Default(NumStores);
695 : // FIXME: Error handling.
0: branch 0 not taken
174: branch 1 taken
696 174: if (Value == NumStores)
697 : Diags.Report(diag::err_drv_invalid_value)
698 0: << Args.getLastArg(OPT_O)->getAsString(Args) << Name;
699 : else
700 174: Opts.AnalysisStoreOpt = Value;
701 : }
702 :
102: branch 2 taken
2421: branch 3 taken
703 2523: if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
704 102: llvm::StringRef Name = A->getValue(Args);
705 : AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
706 : #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
707 : .Case(CMDFLAG, NAME##Model)
708 : #include "clang/Frontend/Analyses.def"
709 102: .Default(NumConstraints);
710 : // FIXME: Error handling.
0: branch 0 not taken
102: branch 1 taken
711 102: if (Value == NumConstraints)
712 : Diags.Report(diag::err_drv_invalid_value)
713 0: << Args.getLastArg(OPT_O)->getAsString(Args) << Name;
714 : else
715 102: Opts.AnalysisConstraintsOpt = Value;
716 : }
717 :
2: branch 2 taken
2521: branch 3 taken
718 2523: if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
719 2: llvm::StringRef Name = A->getValue(Args);
720 : AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
721 : #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
722 : .Case(CMDFLAG, PD_##NAME)
723 : #include "clang/Frontend/Analyses.def"
724 2: .Default(NUM_ANALYSIS_DIAG_CLIENTS);
725 : // FIXME: Error handling.
0: branch 0 not taken
2: branch 1 taken
726 2: if (Value == NUM_ANALYSIS_DIAG_CLIENTS)
727 : Diags.Report(diag::err_drv_invalid_value)
728 0: << Args.getLastArg(OPT_O)->getAsString(Args) << Name;
729 : else
730 2: Opts.AnalysisDiagOpt = Value;
731 : }
732 :
733 2523: Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
734 2523: Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
735 2523: Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
736 2523: Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
737 : Opts.AnalyzeNestedBlocks =
738 2523: Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
739 2523: Opts.PurgeDead = !Args.hasArg(OPT_analyzer_no_purge_dead);
740 2523: Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume);
741 2523: Opts.AnalyzeSpecificFunction = getLastArgValue(Args, OPT_analyze_function);
742 2523: Opts.EnableExperimentalChecks = Args.hasArg(OPT_analyzer_experimental_checks);
743 : Opts.EnableExperimentalInternalChecks =
744 2523: Args.hasArg(OPT_analyzer_experimental_internal_checks);
745 2523: Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
746 2523: }
747 :
748 : static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
749 2523: Diagnostic &Diags) {
750 : using namespace cc1options;
751 : // -Os implies -O2
3: branch 2 taken
2520: branch 3 taken
752 2523: if (Args.hasArg(OPT_Os))
753 3: Opts.OptimizationLevel = 2;
754 : else {
755 2520: Opts.OptimizationLevel = getLastArgIntValue(Args, OPT_O, 0, Diags);
0: branch 0 not taken
2520: branch 1 taken
756 2520: if (Opts.OptimizationLevel > 3) {
757 : Diags.Report(diag::err_drv_invalid_value)
758 0: << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel;
759 0: Opts.OptimizationLevel = 3;
760 : }
761 : }
762 :
763 : // We must always run at least the always inlining pass.
764 : Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining
27: branch 0 taken
2496: branch 1 taken
765 2523: : CodeGenOptions::OnlyAlwaysInlining;
766 :
767 2523: Opts.DebugInfo = Args.hasArg(OPT_g);
768 2523: Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
769 2523: Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
770 2523: Opts.DwarfDebugFlags = getLastArgValue(Args, OPT_dwarf_debug_flags);
771 2523: Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
772 2523: Opts.NoCommon = Args.hasArg(OPT_fno_common);
773 2523: Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
774 2523: Opts.OptimizeSize = Args.hasArg(OPT_Os);
27: branch 0 taken
2496: branch 1 taken
24: branch 2 taken
3: branch 3 taken
775 2523: Opts.UnrollLoops = (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize);
776 :
777 2523: Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
778 2523: Opts.CodeModel = getLastArgValue(Args, OPT_mcode_model);
779 2523: Opts.DebugPass = getLastArgValue(Args, OPT_mdebug_pass);
780 2523: Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim);
781 2523: Opts.FloatABI = getLastArgValue(Args, OPT_mfloat_abi);
782 2523: Opts.LimitFloatPrecision = getLastArgValue(Args, OPT_mlimit_float_precision);
783 2523: Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
784 2523: Opts.ObjCLegacyDispatch = Args.hasArg(OPT_fobjc_legacy_dispatch);
785 2523: Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
786 2523: Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
787 2523: Opts.RelocationModel = getLastArgValue(Args, OPT_mrelocation_model, "pic");
788 :
789 2523: Opts.MainFileName = getLastArgValue(Args, OPT_main_file_name);
790 :
791 : // FIXME: Put elsewhere?
792 : #ifdef NDEBUG
793 : Opts.VerifyModule = 0;
794 : #else
795 2523: Opts.VerifyModule = 1;
796 : #endif
797 2523: }
798 :
799 : static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
800 2523: ArgList &Args) {
801 : using namespace cc1options;
802 2523: Opts.OutputFile = getLastArgValue(Args, OPT_dependency_file);
803 2523: Opts.Targets = getAllArgValues(Args, OPT_MT);
804 2523: Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
805 2523: Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
806 2523: }
807 :
808 : static void ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
809 2523: Diagnostic &Diags) {
810 : using namespace cc1options;
811 2523: Opts.IgnoreWarnings = Args.hasArg(OPT_w);
812 2523: Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
813 2523: Opts.Pedantic = Args.hasArg(OPT_pedantic);
814 2523: Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
815 2523: Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
816 2523: Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics);
817 2523: Opts.ShowColumn = !Args.hasArg(OPT_fno_show_column);
818 2523: Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
819 2523: Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
820 2523: Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
821 2523: Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
822 2523: Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
823 2523: Opts.BinaryOutput = Args.hasArg(OPT_fdiagnostics_binary);
824 : Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
825 2523: DiagnosticOptions::DefaultTabStop, Diags);
2523: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
2523: branch 3 taken
826 2523: if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
827 : Diags.Report(diag::warn_ignoring_ftabstop_value)
828 0: << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
829 0: Opts.TabStop = DiagnosticOptions::DefaultTabStop;
830 : }
831 2523: Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
832 2523: Opts.DumpBuildInformation = getLastArgValue(Args, OPT_dump_build_information);
833 2523: Opts.Warnings = getAllArgValues(Args, OPT_W);
834 2523: }
835 :
836 : static FrontendOptions::InputKind
837 2523: ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, Diagnostic &Diags) {
838 : using namespace cc1options;
839 2523: Opts.ProgramAction = frontend::ParseSyntaxOnly;
2446: branch 2 taken
77: branch 3 taken
840 2523: if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
0: branch 2 not taken
5: branch 3 taken
17: branch 4 taken
1: branch 5 taken
0: branch 6 not taken
0: branch 7 not taken
1: branch 8 taken
3: branch 9 taken
57: branch 10 taken
18: branch 11 taken
3: branch 12 taken
516: branch 13 taken
35: branch 14 taken
0: branch 15 not taken
12: branch 16 taken
44: branch 17 taken
1: branch 18 taken
13: branch 19 taken
2: branch 20 taken
1213: branch 21 taken
2: branch 22 taken
245: branch 23 taken
1: branch 24 taken
51: branch 25 taken
0: branch 26 not taken
188: branch 27 taken
18: branch 28 taken
841 2446: switch (A->getOption().getID()) {
842 : default:
843 0: assert(0 && "Invalid option in group!");
844 : case OPT_ast_dump:
845 5: Opts.ProgramAction = frontend::ASTDump; break;
846 : case OPT_ast_print:
847 17: Opts.ProgramAction = frontend::ASTPrint; break;
848 : case OPT_ast_print_xml:
849 1: Opts.ProgramAction = frontend::ASTPrintXML; break;
850 : case OPT_ast_view:
851 0: Opts.ProgramAction = frontend::ASTView; break;
852 : case OPT_dump_raw_tokens:
853 0: Opts.ProgramAction = frontend::DumpRawTokens; break;
854 : case OPT_dump_record_layouts:
855 1: Opts.ProgramAction = frontend::DumpRecordLayouts; break;
856 : case OPT_dump_tokens:
857 3: Opts.ProgramAction = frontend::DumpTokens; break;
858 : case OPT_S:
859 57: Opts.ProgramAction = frontend::EmitAssembly; break;
860 : case OPT_emit_llvm_bc:
861 18: Opts.ProgramAction = frontend::EmitBC; break;
862 : case OPT_emit_html:
863 3: Opts.ProgramAction = frontend::EmitHTML; break;
864 : case OPT_emit_llvm:
865 516: Opts.ProgramAction = frontend::EmitLLVM; break;
866 : case OPT_emit_llvm_only:
867 35: Opts.ProgramAction = frontend::EmitLLVMOnly; break;
868 : case OPT_emit_obj:
869 0: Opts.ProgramAction = frontend::EmitObj; break;
870 : case OPT_fixit:
871 12: Opts.ProgramAction = frontend::FixIt; break;
872 : case OPT_emit_pch:
873 44: Opts.ProgramAction = frontend::GeneratePCH; break;
874 : case OPT_emit_pth:
875 1: Opts.ProgramAction = frontend::GeneratePTH; break;
876 : case OPT_parse_noop:
877 13: Opts.ProgramAction = frontend::ParseNoop; break;
878 : case OPT_parse_print_callbacks:
879 2: Opts.ProgramAction = frontend::ParsePrintCallbacks; break;
880 : case OPT_fsyntax_only:
881 1213: Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
882 : case OPT_print_decl_contexts:
883 2: Opts.ProgramAction = frontend::PrintDeclContext; break;
884 : case OPT_E:
885 245: Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
886 : case OPT_rewrite_macros:
887 1: Opts.ProgramAction = frontend::RewriteMacros; break;
888 : case OPT_rewrite_objc:
889 51: Opts.ProgramAction = frontend::RewriteObjC; break;
890 : case OPT_rewrite_test:
891 0: Opts.ProgramAction = frontend::RewriteTest; break;
892 : case OPT_analyze:
893 188: Opts.ProgramAction = frontend::RunAnalysis; break;
894 : case OPT_Eonly:
895 18: Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
896 : }
897 : }
0: branch 2 not taken
2523: branch 3 taken
898 2523: if (const Arg *A = Args.getLastArg(OPT_plugin)) {
899 0: Opts.ProgramAction = frontend::PluginAction;
900 0: Opts.ActionName = A->getValue(Args);
901 : }
902 :
87: branch 2 taken
2436: branch 3 taken
903 2523: if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
904 : Opts.CodeCompletionAt =
905 87: ParsedSourceLocation::FromString(A->getValue(Args));
0: branch 1 not taken
87: branch 2 taken
906 87: if (Opts.CodeCompletionAt.FileName.empty())
907 : Diags.Report(diag::err_drv_invalid_value)
908 0: << A->getAsString(Args) << A->getValue(Args);
909 : }
910 : Opts.DebugCodeCompletionPrinter =
911 2523: !Args.hasArg(OPT_no_code_completion_debug_printer);
912 2523: Opts.DisableFree = Args.hasArg(OPT_disable_free);
913 2523: Opts.EmptyInputOnly = Args.hasArg(OPT_empty_input_only);
914 :
915 2523: Opts.FixItLocations.clear();
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
2523: branch 10 taken
916 5046: for (arg_iterator it = Args.filtered_begin(OPT_fixit_at),
917 2523: ie = Args.filtered_end(); it != ie; ++it) {
918 0: const char *Loc = it->getValue(Args);
919 0: ParsedSourceLocation PSL = ParsedSourceLocation::FromString(Loc);
920 :
0: branch 1 not taken
0: branch 2 not taken
921 0: if (PSL.FileName.empty()) {
922 0: Diags.Report(diag::err_drv_invalid_value) << it->getAsString(Args) << Loc;
923 0: continue;
924 : }
925 :
926 0: Opts.FixItLocations.push_back(PSL);
927 : }
928 :
929 2523: Opts.OutputFile = getLastArgValue(Args, OPT_o);
930 2523: Opts.Plugins = getAllArgValues(Args, OPT_load);
931 2523: Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
932 2523: Opts.ShowHelp = Args.hasArg(OPT_help);
933 2523: Opts.ShowMacrosInCodeCompletion = Args.hasArg(OPT_code_completion_macros);
934 2523: Opts.ShowStats = Args.hasArg(OPT_print_stats);
935 2523: Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
936 2523: Opts.ShowVersion = Args.hasArg(OPT_version);
937 2523: Opts.ViewClassInheritance = getLastArgValue(Args, OPT_cxx_inheritance_view);
938 2523: Opts.ASTMergeFiles = getAllArgValues(Args, OPT_ast_merge);
939 :
940 2523: FrontendOptions::InputKind DashX = FrontendOptions::IK_None;
210: branch 2 taken
2313: branch 3 taken
941 2523: if (const Arg *A = Args.getLastArg(OPT_x)) {
942 : DashX = llvm::StringSwitch<FrontendOptions::InputKind>(A->getValue(Args))
943 : .Case("c", FrontendOptions::IK_C)
944 : .Case("cl", FrontendOptions::IK_OpenCL)
945 : .Case("c", FrontendOptions::IK_C)
946 : .Case("cl", FrontendOptions::IK_OpenCL)
947 : .Case("c++", FrontendOptions::IK_CXX)
948 : .Case("objective-c", FrontendOptions::IK_ObjC)
949 : .Case("objective-c++", FrontendOptions::IK_ObjCXX)
950 : .Case("cpp-output", FrontendOptions::IK_PreprocessedC)
951 : .Case("assembler-with-cpp", FrontendOptions::IK_Asm)
952 : .Case("c++-cpp-output", FrontendOptions::IK_PreprocessedCXX)
953 : .Case("objective-c-cpp-output", FrontendOptions::IK_PreprocessedObjC)
954 : .Case("objective-c++-cpp-output", FrontendOptions::IK_PreprocessedObjCXX)
955 : .Case("c-header", FrontendOptions::IK_C)
956 : .Case("objective-c-header", FrontendOptions::IK_ObjC)
957 : .Case("c++-header", FrontendOptions::IK_CXX)
958 : .Case("objective-c++-header", FrontendOptions::IK_ObjCXX)
959 : .Case("ast", FrontendOptions::IK_AST)
960 210: .Default(FrontendOptions::IK_None);
0: branch 0 not taken
210: branch 1 taken
961 210: if (DashX == FrontendOptions::IK_None)
962 : Diags.Report(diag::err_drv_invalid_value)
963 0: << A->getAsString(Args) << A->getValue(Args);
964 : }
965 :
966 : // '-' is the default input if none is given.
967 2523: std::vector<std::string> Inputs = getAllArgValues(Args, OPT_INPUT);
968 2523: Opts.Inputs.clear();
81: branch 1 taken
2442: branch 2 taken
969 2523: if (Inputs.empty())
970 81: Inputs.push_back("-");
2523: branch 1 taken
2523: branch 2 taken
971 5046: for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
972 2523: FrontendOptions::InputKind IK = DashX;
2313: branch 0 taken
210: branch 1 taken
973 2523: if (IK == FrontendOptions::IK_None) {
974 : IK = FrontendOptions::getInputKindForExtension(
975 2313: llvm::StringRef(Inputs[i]).rsplit('.').second);
976 : // FIXME: Remove this hack.
2313: branch 0 taken
0: branch 1 not taken
977 2313: if (i == 0)
978 2313: DashX = IK;
979 : }
980 2523: Opts.Inputs.push_back(std::make_pair(IK, Inputs[i]));
981 : }
982 :
983 2523: return DashX;
984 : }
985 :
986 : std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
987 2372: void *MainAddr) {
988 2372: llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
989 :
2372: branch 1 taken
0: branch 2 not taken
990 2372: if (!P.isEmpty()) {
991 2372: P.eraseComponent(); // Remove /clang from foo/bin/clang
992 2372: P.eraseComponent(); // Remove /bin from foo/bin
993 :
994 : // Get foo/lib/clang/<version>/include
995 2372: P.appendComponent("lib");
996 2372: P.appendComponent("clang");
997 2372: P.appendComponent(CLANG_VERSION_STRING);
998 : }
999 :
1000 2372: return P.str();
1001 : }
1002 :
1003 2523: static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
1004 : using namespace cc1options;
1005 2523: Opts.Sysroot = getLastArgValue(Args, OPT_isysroot, "/");
1006 2523: Opts.Verbose = Args.hasArg(OPT_v);
1007 2523: Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
1008 2523: Opts.UseStandardIncludes = !Args.hasArg(OPT_nostdinc);
1009 2523: Opts.ResourceDir = getLastArgValue(Args, OPT_resource_dir);
1010 :
1011 : // Add -I... and -F... options in order.
5: branch 6 taken
2523: branch 7 taken
1012 5051: for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F),
1013 2523: ie = Args.filtered_end(); it != ie; ++it)
1014 : Opts.AddPath(it->getValue(Args), frontend::Angled, true,
1015 5: /*IsFramework=*/ it->getOption().matches(OPT_F));
1016 :
1017 : // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
1018 2523: llvm::StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
0: branch 2 not taken
2523: branch 3 taken
1019 2523: for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix,
1020 2523: OPT_iwithprefixbefore),
1021 2523: ie = Args.filtered_end(); it != ie; ++it) {
0: branch 4 not taken
0: branch 5 not taken
1022 0: if (it->getOption().matches(OPT_iprefix))
1023 0: Prefix = it->getValue(Args);
0: branch 4 not taken
0: branch 5 not taken
1024 0: else if (it->getOption().matches(OPT_iwithprefix))
1025 : Opts.AddPath(Prefix.str() + it->getValue(Args),
1026 0: frontend::System, false, false);
1027 : else
1028 : Opts.AddPath(Prefix.str() + it->getValue(Args),
1029 0: frontend::Angled, false, false);
1030 : }
1031 :
0: branch 6 not taken
2523: branch 7 taken
1032 5046: for (arg_iterator it = Args.filtered_begin(OPT_idirafter),
1033 2523: ie = Args.filtered_end(); it != ie; ++it)
1034 0: Opts.AddPath(it->getValue(Args), frontend::After, true, false);
0: branch 6 not taken
2523: branch 7 taken
1035 5046: for (arg_iterator it = Args.filtered_begin(OPT_iquote),
1036 2523: ie = Args.filtered_end(); it != ie; ++it)
1037 0: Opts.AddPath(it->getValue(Args), frontend::Quoted, true, false);
0: branch 6 not taken
2523: branch 7 taken
1038 5046: for (arg_iterator it = Args.filtered_begin(OPT_isystem),
1039 2523: ie = Args.filtered_end(); it != ie; ++it)
1040 0: Opts.AddPath(it->getValue(Args), frontend::System, true, false);
1041 :
1042 : // FIXME: Need options for the various environment variables!
1043 2523: }
1044 :
1045 : static void ParseLangArgs(LangOptions &Opts, ArgList &Args,
1046 : FrontendOptions::InputKind IK,
1047 2521: Diagnostic &Diags) {
1048 : // FIXME: Cleanup per-file based stuff.
1049 :
1050 : // Set some properties which depend soley on the input kind; it would be nice
1051 : // to move these to the language standard, and have the driver resolve the
1052 : // input kind + language standard.
4: branch 0 taken
2517: branch 1 taken
1053 2521: if (IK == FrontendOptions::IK_Asm) {
1054 4: Opts.AsmPreprocessor = 1;
1910: branch 0 taken
607: branch 1 taken
1872: branch 2 taken
38: branch 3 taken
1872: branch 4 taken
0: branch 5 not taken
0: branch 6 not taken
1872: branch 7 taken
1055 2517: } else if (IK == FrontendOptions::IK_ObjC ||
1056 : IK == FrontendOptions::IK_ObjCXX ||
1057 : IK == FrontendOptions::IK_PreprocessedObjC ||
1058 : IK == FrontendOptions::IK_PreprocessedObjCXX) {
1059 645: Opts.ObjC1 = Opts.ObjC2 = 1;
1060 : }
1061 :
1062 2521: LangStandard::Kind LangStd = LangStandard::lang_unspecified;
163: branch 2 taken
2358: branch 3 taken
1063 2521: if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
1064 : LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
1065 : #define LANGSTANDARD(id, name, desc, features) \
1066 : .Case(name, LangStandard::lang_##id)
1067 : #include "clang/Frontend/LangStandards.def"
1068 163: .Default(LangStandard::lang_unspecified);
0: branch 0 not taken
163: branch 1 taken
1069 163: if (LangStd == LangStandard::lang_unspecified)
1070 : Diags.Report(diag::err_drv_invalid_value)
1071 0: << A->getAsString(Args) << A->getValue(Args);
1072 : }
1073 :
2358: branch 0 taken
163: branch 1 taken
1074 2521: if (LangStd == LangStandard::lang_unspecified) {
1075 : // Based on the base language, pick one.
0: branch 0 not taken
3: branch 1 taken
1575: branch 2 taken
780: branch 3 taken
0: branch 4 not taken
1076 2358: switch (IK) {
1077 : case FrontendOptions::IK_None:
1078 : case FrontendOptions::IK_AST:
1079 0: assert(0 && "Invalid input kind!");
1080 : case FrontendOptions::IK_OpenCL:
1081 3: LangStd = LangStandard::lang_opencl;
1082 3: break;
1083 : case FrontendOptions::IK_Asm:
1084 : case FrontendOptions::IK_C:
1085 : case FrontendOptions::IK_PreprocessedC:
1086 : case FrontendOptions::IK_ObjC:
1087 : case FrontendOptions::IK_PreprocessedObjC:
1088 1575: LangStd = LangStandard::lang_gnu99;
1089 1575: break;
1090 : case FrontendOptions::IK_CXX:
1091 : case FrontendOptions::IK_PreprocessedCXX:
1092 : case FrontendOptions::IK_ObjCXX:
1093 : case FrontendOptions::IK_PreprocessedObjCXX:
1094 780: LangStd = LangStandard::lang_gnucxx98;
1095 : break;
1096 : }
1097 : }
1098 :
1099 2521: const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1100 2521: Opts.BCPLComment = Std.hasBCPLComments();
1101 2521: Opts.C99 = Std.isC99();
1102 2521: Opts.CPlusPlus = Std.isCPlusPlus();
1103 2521: Opts.CPlusPlus0x = Std.isCPlusPlus0x();
1104 2521: Opts.Digraphs = Std.hasDigraphs();
1105 2521: Opts.GNUMode = Std.isGNUMode();
1106 2521: Opts.GNUInline = !Std.isC99();
1107 2521: Opts.HexFloats = Std.hasHexFloats();
1108 2521: Opts.ImplicitInt = Std.hasImplicitInt();
1109 :
1110 : // OpenCL has some additional defaults.
3: branch 0 taken
2518: branch 1 taken
1111 2521: if (LangStd == LangStandard::lang_opencl) {
1112 3: Opts.OpenCL = 1;
1113 3: Opts.AltiVec = 1;
1114 3: Opts.CXXOperatorNames = 1;
1115 3: Opts.LaxVectorConversions = 1;
1116 : }
1117 :
1118 : // OpenCL and C++ both have bool, true, false keywords.
2518: branch 0 taken
3: branch 1 taken
893: branch 2 taken
1625: branch 3 taken
1119 2521: Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1120 :
893: branch 0 taken
1628: branch 1 taken
1121 2521: if (Opts.CPlusPlus)
1122 893: Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
1123 :
4: branch 2 taken
2517: branch 3 taken
1124 2521: if (Args.hasArg(OPT_fobjc_gc_only))
1125 4: Opts.setGCMode(LangOptions::GCOnly);
44: branch 2 taken
2473: branch 3 taken
1126 2517: else if (Args.hasArg(OPT_fobjc_gc))
1127 44: Opts.setGCMode(LangOptions::HybridGC);
1128 :
0: branch 2 not taken
2521: branch 3 taken
1129 2521: if (Args.hasArg(OPT_print_ivar_layout))
1130 0: Opts.ObjCGCBitmapPrint = 1;
1131 :
3: branch 2 taken
2518: branch 3 taken
1132 2521: if (Args.hasArg(OPT_faltivec))
1133 3: Opts.AltiVec = 1;
1134 :
0: branch 2 not taken
2521: branch 3 taken
1135 2521: if (Args.hasArg(OPT_pthread))
1136 0: Opts.POSIXThreads = 1;
1137 :
1138 : llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
1139 2521: "default");
2517: branch 2 taken
4: branch 3 taken
1140 2521: if (Vis == "default")
1141 2517: Opts.setVisibilityMode(LangOptions::Default);
3: branch 2 taken
1: branch 3 taken
1142 4: else if (Vis == "hidden")
1143 3: Opts.setVisibilityMode(LangOptions::Hidden);
1: branch 2 taken
0: branch 3 not taken
1144 1: else if (Vis == "protected")
1145 1: Opts.setVisibilityMode(LangOptions::Protected);
1146 : else
1147 : Diags.Report(diag::err_drv_invalid_value)
1148 0: << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
1149 :
1150 2521: Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
1151 :
1152 : // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1153 : // is specified, or -std is set to a conforming mode.
1154 2521: Opts.Trigraphs = !Opts.GNUMode;
13: branch 2 taken
2508: branch 3 taken
1155 2521: if (Args.hasArg(OPT_trigraphs))
1156 13: Opts.Trigraphs = 1;
1157 :
1158 : Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
1159 : OPT_fno_dollars_in_identifiers,
1160 2521: !Opts.AsmPreprocessor);
1161 2521: Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
1162 2521: Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
1163 2521: Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
1: branch 2 taken
2520: branch 3 taken
1164 2521: if (Args.hasArg(OPT_fno_lax_vector_conversions))
1165 1: Opts.LaxVectorConversions = 0;
1: branch 2 taken
2520: branch 3 taken
1166 2521: if (Args.hasArg(OPT_fno_threadsafe_statics))
1167 1: Opts.ThreadsafeStatics = 0;
1168 2521: Opts.Exceptions = Args.hasArg(OPT_fexceptions);
1169 2521: Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
1170 2521: Opts.Blocks = Args.hasArg(OPT_fblocks);
1171 2521: Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
1172 2521: Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
1173 2521: Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
2521: branch 2 taken
0: branch 3 not taken
29: branch 4 taken
2492: branch 5 taken
1174 2521: Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
1175 2521: Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
1176 2521: Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
1177 2521: Opts.AccessControl = Args.hasArg(OPT_faccess_control);
1178 2521: Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
1179 2521: Opts.MathErrno = Args.hasArg(OPT_fmath_errno);
1180 : Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
1181 2521: Diags);
1182 2521: Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
1183 : Opts.ObjCConstantStringClass = getLastArgValue(Args,
1184 2521: OPT_fconstant_string_class);
1185 2521: Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
1186 2521: Opts.ObjCNonFragileABI2 = Args.hasArg(OPT_fobjc_nonfragile_abi2);
1: branch 0 taken
2520: branch 1 taken
1187 2521: if (Opts.ObjCNonFragileABI2)
1188 1: Opts.ObjCNonFragileABI = true;
1189 2521: Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
1190 2521: Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
1191 2521: Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
1192 2521: Opts.Static = Args.hasArg(OPT_static_define);
1193 2521: Opts.OptimizeSize = 0;
1194 :
1195 : // FIXME: Eliminate this dependency.
1196 : unsigned Opt =
3: branch 2 taken
2518: branch 3 taken
1197 2521: Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
1198 2521: Opts.Optimize = Opt != 0;
1199 :
1200 : // This is the __NO_INLINE__ define, which just depends on things like the
1201 : // optimization level and -fno-inline, not actually whether the backend has
1202 : // inlining enabled.
1203 : //
1204 : // FIXME: This is affected by other options (-fno-inline).
1205 2521: Opts.NoInline = !Opt;
1206 :
1207 2521: unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
0: branch 0 not taken
2516: branch 1 taken
4: branch 2 taken
1: branch 3 taken
1208 2521: switch (SSP) {
1209 : default:
1210 : Diags.Report(diag::err_drv_invalid_value)
1211 0: << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
1212 0: break;
1213 2516: case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
1214 4: case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break;
1215 1: case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
1216 : }
1217 2521: }
1218 :
1219 : static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
1220 2523: Diagnostic &Diags) {
1221 : using namespace cc1options;
1222 2523: Opts.ImplicitPCHInclude = getLastArgValue(Args, OPT_include_pch);
1223 2523: Opts.ImplicitPTHInclude = getLastArgValue(Args, OPT_include_pth);
0: branch 2 not taken
2523: branch 3 taken
1224 2523: if (const Arg *A = Args.getLastArg(OPT_token_cache))
1225 0: Opts.TokenCache = A->getValue(Args);
1226 : else
1227 2523: Opts.TokenCache = Opts.ImplicitPTHInclude;
1228 2523: Opts.UsePredefines = !Args.hasArg(OPT_undef);
1229 :
1230 : // Add macros from the command line.
78: branch 6 taken
2523: branch 7 taken
1231 5124: for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
1232 2523: ie = Args.filtered_end(); it != ie; ++it) {
78: branch 4 taken
0: branch 5 not taken
1233 78: if (it->getOption().matches(OPT_D))
1234 78: Opts.addMacroDef(it->getValue(Args));
1235 : else
1236 0: Opts.addMacroUndef(it->getValue(Args));
1237 : }
1238 :
1239 2523: Opts.MacroIncludes = getAllArgValues(Args, OPT_imacros);
1240 :
1241 : // Add the ordered list of -includes.
65: branch 2 taken
2523: branch 3 taken
1242 2588: for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
1243 2523: OPT_include_pth),
1244 2523: ie = Args.filtered_end(); it != ie; ++it) {
1245 : // PCH is handled specially, we need to extra the original include path.
36: branch 4 taken
29: branch 5 taken
1246 65: if (it->getOption().matches(OPT_include_pch)) {
1247 : std::string OriginalFile =
1248 36: PCHReader::getOriginalSourceFile(it->getValue(Args), Diags);
0: branch 1 not taken
36: branch 2 taken
1249 36: if (OriginalFile.empty())
1250 0: continue;
1251 :
36: branch 2 taken
0: branch 3 not taken
1252 36: Opts.Includes.push_back(OriginalFile);
1253 : } else
1254 29: Opts.Includes.push_back(it->getValue(Args));
1255 : }
1256 :
6: branch 6 taken
2523: branch 7 taken
1257 5052: for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
1258 2523: ie = Args.filtered_end(); it != ie; ++it) {
1259 : std::pair<llvm::StringRef,llvm::StringRef> Split =
1260 6: llvm::StringRef(it->getValue(Args)).split(';');
1261 :
0: branch 1 not taken
6: branch 2 taken
1262 6: if (Split.second.empty()) {
1263 0: Diags.Report(diag::err_drv_invalid_remap_file) << it->getAsString(Args);
1264 0: continue;
1265 : }
1266 :
1267 6: Opts.addRemappedFile(Split.first, Split.second);
1268 : }
1269 2523: }
1270 :
1271 : static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
1272 2523: ArgList &Args) {
1273 : using namespace cc1options;
1274 2523: Opts.ShowCPP = !Args.hasArg(OPT_dM);
2478: branch 2 taken
45: branch 3 taken
2: branch 6 taken
2476: branch 7 taken
1275 2523: Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
1276 2523: Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
1277 2523: Opts.ShowComments = Args.hasArg(OPT_C);
1278 2523: Opts.ShowMacroComments = Args.hasArg(OPT_CC);
1279 2523: }
1280 :
1281 2523: static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
1282 : using namespace cc1options;
1283 2523: Opts.ABI = getLastArgValue(Args, OPT_target_abi);
1284 2523: Opts.CPU = getLastArgValue(Args, OPT_target_cpu);
1285 2523: Opts.Triple = getLastArgValue(Args, OPT_triple);
1286 2523: Opts.Features = getAllArgValues(Args, OPT_target_feature);
1287 :
1288 : // Use the host triple if unspecified.
1933: branch 1 taken
590: branch 2 taken
1289 2523: if (Opts.Triple.empty())
1290 1933: Opts.Triple = llvm::sys::getHostTriple();
1291 2523: }
1292 :
1293 : //
1294 :
1295 : void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
1296 : const char **ArgBegin,
1297 : const char **ArgEnd,
1298 2523: Diagnostic &Diags) {
1299 : // Parse the arguments.
1300 2523: llvm::OwningPtr<OptTable> Opts(createCC1OptTable());
1301 : unsigned MissingArgIndex, MissingArgCount;
1302 : llvm::OwningPtr<InputArgList> Args(
1303 2523: Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount));
1304 :
1305 : // Check for missing argument error.
0: branch 0 not taken
2523: branch 1 taken
1306 2523: if (MissingArgCount)
1307 : Diags.Report(diag::err_drv_missing_argument)
1308 0: << Args->getArgString(MissingArgIndex) << MissingArgCount;
1309 :
1310 : // Issue errors on unknown arguments.
1: branch 7 taken
2523: branch 8 taken
1311 5047: for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
1312 2523: ie = Args->filtered_end(); it != ie; ++it)
1313 1: Diags.Report(diag::err_drv_unknown_argument) << it->getAsString(*Args);
1314 :
1315 2523: ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags);
1316 2523: ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, Diags);
1317 2523: ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args);
1318 2523: ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags);
1319 : FrontendOptions::InputKind DashX =
1320 2523: ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags);
1321 2523: ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args);
2521: branch 0 taken
2: branch 1 taken
1322 2523: if (DashX != FrontendOptions::IK_AST)
1323 2521: ParseLangArgs(Res.getLangOpts(), *Args, DashX, Diags);
1324 2523: ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, Diags);
1325 2523: ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args);
1326 2523: ParseTargetArgs(Res.getTargetOpts(), *Args);
1327 2523: }
Generated: 2010-02-10 01:31 by zcov