 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
80.1% |
432 / 539 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
93.3% |
503 / 539 |
| |
|
Line Coverage: |
87.2% |
513 / 588 |
| |
 |
|
 |
1 : //===--- Driver.cpp - Clang GCC Compatible Driver -----------------------*-===//
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/Driver/Driver.h"
11 :
12 : #include "clang/Driver/Action.h"
13 : #include "clang/Driver/Arg.h"
14 : #include "clang/Driver/ArgList.h"
15 : #include "clang/Driver/Compilation.h"
16 : #include "clang/Driver/DriverDiagnostic.h"
17 : #include "clang/Driver/HostInfo.h"
18 : #include "clang/Driver/Job.h"
19 : #include "clang/Driver/OptTable.h"
20 : #include "clang/Driver/Option.h"
21 : #include "clang/Driver/Options.h"
22 : #include "clang/Driver/Tool.h"
23 : #include "clang/Driver/ToolChain.h"
24 : #include "clang/Driver/Types.h"
25 :
26 : #include "clang/Basic/Version.h"
27 :
28 : #include "llvm/ADT/StringSet.h"
29 : #include "llvm/ADT/OwningPtr.h"
30 : #include "llvm/Support/PrettyStackTrace.h"
31 : #include "llvm/Support/raw_ostream.h"
32 : #include "llvm/System/Path.h"
33 : #include "llvm/System/Program.h"
34 :
35 : #include "InputInfo.h"
36 :
37 : #include <map>
38 :
39 : using namespace clang::driver;
40 : using namespace clang;
41 :
42 : // Used to set values for "production" clang, for releases.
43 : // #define USE_PRODUCTION_CLANG
44 :
45 : Driver::Driver(llvm::StringRef _Name, llvm::StringRef _Dir,
46 : llvm::StringRef _DefaultHostTriple,
47 : llvm::StringRef _DefaultImageName,
48 248: bool IsProduction, Diagnostic &_Diags)
49 : : Opts(createDriverOptTable()), Diags(_Diags),
50 : Name(_Name), Dir(_Dir), DefaultHostTriple(_DefaultHostTriple),
51 : DefaultImageName(_DefaultImageName),
52 : Host(0),
53 : CCCGenericGCCName("gcc"), CCCIsCXX(false), CCCEcho(false),
54 : CCCPrintBindings(false), CheckInputsExist(true), CCCUseClang(true),
55 : CCCUseClangCXX(true), CCCUseClangCPP(true), CCCUsePCH(true),
56 248: SuppressMissingInputWarning(false) {
0: branch 0 not taken
248: branch 1 taken
248: branch 2 taken
248: branch 3 taken
57 248: if (IsProduction) {
58 : // In a "production" build, only use clang on architectures we expect to
59 : // work, and don't use clang C++.
60 : //
61 : // During development its more convenient to always have the driver use
62 : // clang, but we don't want users to be confused when things don't work, or
63 : // to file bugs for things we don't support.
64 0: CCCClangArchs.insert(llvm::Triple::x86);
65 0: CCCClangArchs.insert(llvm::Triple::x86_64);
66 0: CCCClangArchs.insert(llvm::Triple::arm);
67 :
68 0: CCCUseClangCXX = false;
69 : }
70 :
71 : // Compute the path to the resource directory.
72 248: llvm::sys::Path P(Dir);
73 248: P.eraseComponent(); // Remove /bin from foo/bin
74 248: P.appendComponent("lib");
75 248: P.appendComponent("clang");
76 248: P.appendComponent(CLANG_VERSION_STRING);
77 248: ResourceDir = P.str();
78 248: }
79 :
80 248: Driver::~Driver() {
248: branch 0 taken
0: branch 1 not taken
248: branch 4 taken
248: branch 5 taken
81 248: delete Opts;
248: branch 0 taken
0: branch 1 not taken
248: branch 3 taken
248: branch 4 taken
82 248: delete Host;
83 248: }
84 :
85 : InputArgList *Driver::ParseArgStrings(const char **ArgBegin,
86 248: const char **ArgEnd) {
87 248: llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
88 : unsigned MissingArgIndex, MissingArgCount;
89 : InputArgList *Args = getOpts().ParseArgs(ArgBegin, ArgEnd,
90 248: MissingArgIndex, MissingArgCount);
91 :
92 : // Check for missing argument error.
2: branch 0 taken
246: branch 1 taken
93 248: if (MissingArgCount)
94 : Diag(clang::diag::err_drv_missing_argument)
95 2: << Args->getArgString(MissingArgIndex) << MissingArgCount;
96 :
97 : // Check for unsupported options.
1426: branch 2 taken
248: branch 3 taken
98 1674: for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
99 : it != ie; ++it) {
100 1426: Arg *A = *it;
0: branch 2 not taken
1426: branch 3 taken
101 1426: if (A->getOption().isUnsupported()) {
102 0: Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
103 0: continue;
104 : }
105 : }
106 :
107 248: return Args;
108 : }
109 :
110 248: Compilation *Driver::BuildCompilation(int argc, const char **argv) {
111 248: llvm::PrettyStackTraceString CrashInfo("Compilation construction");
112 :
113 : // FIXME: Handle environment options which effect driver behavior, somewhere
114 : // (client?). GCC_EXEC_PREFIX, COMPILER_PATH, LIBRARY_PATH, LPATH,
115 : // CC_PRINT_OPTIONS.
116 :
117 : // FIXME: What are we going to do with -V and -b?
118 :
119 : // FIXME: This stuff needs to go into the Compilation, not the driver.
120 248: bool CCCPrintOptions = false, CCCPrintActions = false;
121 :
122 248: const char **Start = argv + 1, **End = argv + argc;
123 248: const char *HostTriple = DefaultHostTriple.c_str();
124 :
125 248: InputArgList *Args = ParseArgStrings(Start, End);
126 :
127 : // -no-canonical-prefixes is used very early in main.
128 248: Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
129 :
130 : // Extract -ccc args.
131 : //
132 : // FIXME: We need to figure out where this behavior should live. Most of it
133 : // should be outside in the client; the parts that aren't should have proper
134 : // options, either by introducing new ones or by overloading gcc ones like -V
135 : // or -b.
136 248: CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
137 248: CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
138 248: CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
248: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
248: branch 5 taken
139 248: CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX;
140 248: CCCEcho = Args->hasArg(options::OPT_ccc_echo);
0: branch 2 not taken
248: branch 3 taken
141 248: if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
142 0: CCCGenericGCCName = A->getValue(*Args);
143 : CCCUseClangCXX = Args->hasFlag(options::OPT_ccc_clang_cxx,
144 : options::OPT_ccc_no_clang_cxx,
145 248: CCCUseClangCXX);
146 : CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
147 248: options::OPT_ccc_pch_is_pth);
148 248: CCCUseClang = !Args->hasArg(options::OPT_ccc_no_clang);
149 248: CCCUseClangCPP = !Args->hasArg(options::OPT_ccc_no_clang_cpp);
6: branch 2 taken
242: branch 3 taken
150 248: if (const Arg *A = Args->getLastArg(options::OPT_ccc_clang_archs)) {
151 6: llvm::StringRef Cur = A->getValue(*Args);
152 :
153 6: CCCClangArchs.clear();
3: branch 1 taken
6: branch 2 taken
154 15: while (!Cur.empty()) {
155 3: std::pair<llvm::StringRef, llvm::StringRef> Split = Cur.split(',');
156 :
3: branch 1 taken
0: branch 2 not taken
157 3: if (!Split.first.empty()) {
158 : llvm::Triple::ArchType Arch =
159 3: llvm::Triple(Split.first, "", "").getArch();
160 :
0: branch 0 not taken
3: branch 1 taken
161 3: if (Arch == llvm::Triple::UnknownArch) {
162 0: Diag(clang::diag::err_drv_invalid_arch_name) << Arch;
163 0: continue;
164 : }
165 :
166 3: CCCClangArchs.insert(Arch);
167 : }
168 :
169 3: Cur = Split.second;
170 : }
171 : }
97: branch 2 taken
151: branch 3 taken
172 248: if (const Arg *A = Args->getLastArg(options::OPT_ccc_host_triple))
173 97: HostTriple = A->getValue(*Args);
0: branch 2 not taken
248: branch 3 taken
174 248: if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
175 0: Dir = A->getValue(*Args);
176 :
177 248: Host = GetHostInfo(HostTriple);
178 :
179 : // The compilation takes ownership of Args.
180 248: Compilation *C = new Compilation(*this, *Host->CreateToolChain(*Args), Args);
181 :
182 : // FIXME: This behavior shouldn't be here.
4: branch 0 taken
244: branch 1 taken
183 248: if (CCCPrintOptions) {
184 4: PrintOptions(C->getArgs());
185 4: return C;
186 : }
187 :
4: branch 1 taken
240: branch 2 taken
188 244: if (!HandleImmediateArgs(*C))
189 4: return C;
190 :
191 : // Construct the list of abstract actions to perform for this compilation. We
192 : // avoid passing a Compilation here simply to enforce the abstraction that
193 : // pipelining is not host or toolchain dependent (other than the driver driver
194 : // test).
60: branch 1 taken
180: branch 2 taken
195 240: if (Host->useDriverDriver())
196 60: BuildUniversalActions(C->getArgs(), C->getActions());
197 : else
198 180: BuildActions(C->getArgs(), C->getActions());
199 :
17: branch 0 taken
223: branch 1 taken
200 240: if (CCCPrintActions) {
201 17: PrintActions(*C);
202 17: return C;
203 : }
204 :
205 223: BuildJobs(*C);
206 :
207 223: return C;
208 : }
209 :
210 239: int Driver::ExecuteCompilation(const Compilation &C) const {
211 : // Just print if -### was present.
52: branch 3 taken
187: branch 4 taken
212 239: if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
213 52: C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
214 52: return 0;
215 : }
216 :
217 : // If there were errors building the compilation, quit now.
4: branch 2 taken
183: branch 3 taken
218 187: if (getDiags().getNumErrors())
219 4: return 1;
220 :
221 183: const Command *FailingCommand = 0;
222 183: int Res = C.ExecuteJob(C.getJobs(), FailingCommand);
223 :
224 : // Remove temp files.
225 183: C.CleanupFileList(C.getTempFiles());
226 :
227 : // If the compilation failed, remove result files as well.
5: branch 0 taken
178: branch 1 taken
5: branch 5 taken
0: branch 6 not taken
5: branch 7 taken
178: branch 8 taken
228 183: if (Res != 0 && !C.getArgs().hasArg(options::OPT_save_temps))
229 5: C.CleanupFileList(C.getResultFiles(), true);
230 :
231 : // Print extra information about abnormal failures, if possible.
5: branch 0 taken
178: branch 1 taken
232 183: if (Res) {
233 : // This is ad-hoc, but we don't want to be excessively noisy. If the result
234 : // status was 1, assume the command failed normally. In particular, if it
235 : // was the compiler then assume it gave a reasonable error code. Failures in
236 : // other tools are less common, and they generally have worse diagnostics,
237 : // so always print the diagnostic there.
238 5: const Action &Source = FailingCommand->getSource();
239 : bool IsFriendlyTool = (isa<PreprocessJobAction>(Source) ||
240 : isa<PrecompileJobAction>(Source) ||
241 : isa<AnalyzeJobAction>(Source) ||
5: branch 1 taken
0: branch 2 not taken
5: branch 4 taken
0: branch 5 not taken
5: branch 7 taken
0: branch 8 not taken
5: branch 10 taken
0: branch 11 not taken
242 5: isa<CompileJobAction>(Source));
243 :
5: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
5: branch 3 taken
244 5: if (!IsFriendlyTool || Res != 1) {
245 : // FIXME: See FIXME above regarding result code interpretation.
0: branch 0 not taken
0: branch 1 not taken
246 0: if (Res < 0)
247 : Diag(clang::diag::err_drv_command_signalled)
248 0: << Source.getClassName() << -Res;
249 : else
250 : Diag(clang::diag::err_drv_command_failed)
251 0: << Source.getClassName() << Res;
252 : }
253 : }
254 :
255 183: return Res;
256 : }
257 :
258 4: void Driver::PrintOptions(const ArgList &Args) const {
259 4: unsigned i = 0;
21: branch 2 taken
4: branch 3 taken
260 25: for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
261 : it != ie; ++it, ++i) {
262 21: Arg *A = *it;
263 : llvm::errs() << "Option " << i << " - "
264 : << "Name: \"" << A->getOption().getName() << "\", "
265 21: << "Values: {";
17: branch 1 taken
21: branch 2 taken
266 38: for (unsigned j = 0; j < A->getNumValues(); ++j) {
4: branch 0 taken
13: branch 1 taken
267 17: if (j)
268 4: llvm::errs() << ", ";
269 17: llvm::errs() << '"' << A->getValue(Args, j) << '"';
270 : }
271 21: llvm::errs() << "}\n";
272 : }
273 4: }
274 :
275 : // FIXME: Move -ccc options to real options in the .td file (or eliminate), and
276 : // then move to using OptTable::PrintHelp.
277 2: void Driver::PrintHelp(bool ShowHidden) const {
278 : getOpts().PrintHelp(llvm::outs(), Name.c_str(),
279 2: "clang \"gcc-compatible\" driver", ShowHidden);
280 2: }
281 :
282 54: void Driver::PrintVersion(const Compilation &C, llvm::raw_ostream &OS) const {
283 : // FIXME: The following handlers should use a callback mechanism, we don't
284 : // know what the client would like to do.
285 54: OS << getClangFullVersion() << '\n';
286 54: const ToolChain &TC = C.getDefaultToolChain();
287 54: OS << "Target: " << TC.getTripleString() << '\n';
288 :
289 : // Print the threading model.
290 : //
291 : // FIXME: Implement correctly.
292 54: OS << "Thread model: " << "posix" << '\n';
293 54: }
294 :
295 244: bool Driver::HandleImmediateArgs(const Compilation &C) {
296 : // The order these options are handled in in gcc is all over the place, but we
297 : // don't expect inconsistencies w.r.t. that to matter in practice.
298 :
1: branch 3 taken
243: branch 4 taken
299 244: if (C.getArgs().hasArg(options::OPT_dumpversion)) {
300 1: llvm::outs() << CLANG_VERSION_STRING "\n";
301 1: return false;
302 : }
303 :
242: branch 3 taken
1: branch 4 taken
1: branch 8 taken
241: branch 9 taken
2: branch 10 taken
241: branch 11 taken
304 243: if (C.getArgs().hasArg(options::OPT__help) ||
305 : C.getArgs().hasArg(options::OPT__help_hidden)) {
306 2: PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
307 2: return false;
308 : }
309 :
0: branch 3 not taken
241: branch 4 taken
310 241: if (C.getArgs().hasArg(options::OPT__version)) {
311 : // Follow gcc behavior and use stdout for --version and stderr for -v.
312 0: PrintVersion(C, llvm::outs());
313 0: return false;
314 : }
315 :
237: branch 3 taken
4: branch 4 taken
50: branch 8 taken
187: branch 9 taken
54: branch 10 taken
187: branch 11 taken
316 241: if (C.getArgs().hasArg(options::OPT_v) ||
317 : C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
318 54: PrintVersion(C, llvm::errs());
319 54: SuppressMissingInputWarning = true;
320 : }
321 :
322 241: const ToolChain &TC = C.getDefaultToolChain();
1: branch 3 taken
240: branch 4 taken
323 241: if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
324 1: llvm::outs() << "programs: =";
1: branch 2 taken
1: branch 3 taken
325 3: for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
326 1: ie = TC.getProgramPaths().end(); it != ie; ++it) {
0: branch 2 not taken
1: branch 3 taken
327 1: if (it != TC.getProgramPaths().begin())
328 0: llvm::outs() << ':';
329 1: llvm::outs() << *it;
330 : }
331 1: llvm::outs() << "\n";
332 1: llvm::outs() << "libraries: =";
7: branch 2 taken
1: branch 3 taken
333 9: for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
334 1: ie = TC.getFilePaths().end(); it != ie; ++it) {
6: branch 2 taken
1: branch 3 taken
335 7: if (it != TC.getFilePaths().begin())
336 6: llvm::outs() << ':';
337 7: llvm::outs() << *it;
338 : }
339 1: llvm::outs() << "\n";
340 1: return false;
341 : }
342 :
343 : // FIXME: The following handlers should use a callback mechanism, we don't
344 : // know what the client would like to do.
0: branch 3 not taken
240: branch 4 taken
345 240: if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
346 0: llvm::outs() << GetFilePath(A->getValue(C.getArgs()), TC) << "\n";
347 0: return false;
348 : }
349 :
0: branch 3 not taken
240: branch 4 taken
350 240: if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
351 0: llvm::outs() << GetProgramPath(A->getValue(C.getArgs()), TC) << "\n";
352 0: return false;
353 : }
354 :
0: branch 3 not taken
240: branch 4 taken
355 240: if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
356 0: llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
357 0: return false;
358 : }
359 :
0: branch 3 not taken
240: branch 4 taken
360 240: if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
361 : // FIXME: We need tool chain support for this.
362 0: llvm::outs() << ".;\n";
363 :
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
364 0: switch (C.getDefaultToolChain().getTriple().getArch()) {
365 : default:
366 0: break;
367 :
368 : case llvm::Triple::x86_64:
369 0: llvm::outs() << "x86_64;@m64" << "\n";
370 0: break;
371 :
372 : case llvm::Triple::ppc64:
373 0: llvm::outs() << "ppc64;@m64" << "\n";
374 : break;
375 : }
376 0: return false;
377 : }
378 :
379 : // FIXME: What is the difference between print-multi-directory and
380 : // print-multi-os-directory?
240: branch 3 taken
0: branch 4 not taken
0: branch 8 not taken
240: branch 9 taken
0: branch 10 not taken
240: branch 11 taken
381 240: if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
382 : C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
383 0: switch (C.getDefaultToolChain().getTriple().getArch()) {
384 : default:
385 : case llvm::Triple::x86:
386 : case llvm::Triple::ppc:
387 0: llvm::outs() << "." << "\n";
388 0: break;
389 :
390 : case llvm::Triple::x86_64:
391 0: llvm::outs() << "x86_64" << "\n";
392 0: break;
393 :
394 : case llvm::Triple::ppc64:
395 0: llvm::outs() << "ppc64" << "\n";
396 : break;
397 : }
398 0: return false;
399 : }
400 :
401 240: return true;
402 : }
403 :
404 : static unsigned PrintActions1(const Compilation &C, Action *A,
405 83: std::map<Action*, unsigned> &Ids) {
2: branch 1 taken
81: branch 2 taken
406 83: if (Ids.count(A))
407 2: return Ids[A];
408 :
409 81: std::string str;
410 81: llvm::raw_string_ostream os(str);
411 :
412 81: os << Action::getClassName(A->getKind()) << ", ";
22: branch 1 taken
59: branch 2 taken
413 81: if (InputAction *IA = dyn_cast<InputAction>(A)) {
414 22: os << "\"" << IA->getInputArg().getValue(C.getArgs()) << "\"";
9: branch 1 taken
50: branch 2 taken
415 59: } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
416 : os << '"' << (BIA->getArchName() ? BIA->getArchName() :
417 : C.getDefaultToolChain().getArchName()) << '"'
4: branch 3 taken
5: branch 4 taken
418 9: << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
419 : } else {
420 50: os << "{";
57: branch 2 taken
50: branch 3 taken
421 157: for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
422 57: os << PrintActions1(C, *it, Ids);
423 57: ++it;
7: branch 0 taken
50: branch 1 taken
424 57: if (it != ie)
425 7: os << ", ";
426 : }
427 50: os << "}";
428 : }
429 :
430 81: unsigned Id = Ids.size();
431 81: Ids[A] = Id;
432 : llvm::errs() << Id << ": " << os.str() << ", "
433 81: << types::getTypeName(A->getType()) << "\n";
434 :
435 81: return Id;
436 : }
437 :
438 17: void Driver::PrintActions(const Compilation &C) const {
439 17: std::map<Action*, unsigned> Ids;
17: branch 2 taken
17: branch 3 taken
440 51: for (ActionList::const_iterator it = C.getActions().begin(),
441 17: ie = C.getActions().end(); it != ie; ++it)
442 34: PrintActions1(C, *it, Ids);
443 17: }
444 :
445 : void Driver::BuildUniversalActions(const ArgList &Args,
446 60: ActionList &Actions) const {
447 60: llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
448 : // Collect the list of architectures. Duplicates are allowed, but should only
449 : // be handled once (in the order seen).
450 60: llvm::StringSet<> ArchNames;
451 60: llvm::SmallVector<const char *, 4> Archs;
454: branch 2 taken
60: branch 3 taken
452 514: for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
453 : it != ie; ++it) {
454 454: Arg *A = *it;
455 :
23: branch 3 taken
431: branch 4 taken
456 454: if (A->getOption().matches(options::OPT_arch)) {
457 : // Validate the option here; we don't save the type here because its
458 : // particular spelling may participate in other driver choices.
459 : llvm::Triple::ArchType Arch =
460 23: llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
0: branch 0 not taken
23: branch 1 taken
461 23: if (Arch == llvm::Triple::UnknownArch) {
462 : Diag(clang::diag::err_drv_invalid_arch_name)
463 0: << A->getAsString(Args);
464 0: continue;
465 : }
466 :
467 23: A->claim();
23: branch 6 taken
0: branch 7 not taken
468 23: if (ArchNames.insert(A->getValue(Args)))
469 23: Archs.push_back(A->getValue(Args));
470 : }
471 : }
472 :
473 : // When there is no explicit arch for this platform, make sure we still bind
474 : // the architecture (to the default) so that -Xarch_ is handled correctly.
41: branch 1 taken
19: branch 2 taken
475 60: if (!Archs.size())
476 41: Archs.push_back(0);
477 :
478 : // FIXME: We killed off some others but these aren't yet detected in a
479 : // functional manner. If we added information to jobs about which "auxiliary"
480 : // files they wrote then we could detect the conflict these cause downstream.
4: branch 1 taken
56: branch 2 taken
481 60: if (Archs.size() > 1) {
482 : // No recovery needed, the point of this is just to prevent
483 : // overwriting the same files.
0: branch 2 not taken
4: branch 3 taken
484 4: if (const Arg *A = Args.getLastArg(options::OPT_save_temps))
485 : Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs)
486 0: << A->getAsString(Args);
487 : }
488 :
489 60: ActionList SingleActions;
490 60: BuildActions(Args, SingleActions);
491 :
492 : // Add in arch binding and lipo (if necessary) for every top level action.
58: branch 2 taken
60: branch 3 taken
493 118: for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
494 58: Action *Act = SingleActions[i];
495 :
496 : // Make sure we can lipo this kind of output. If not (and it is an actual
497 : // output) then we disallow, since we can't create an output file with the
498 : // right name without overwriting it. We could remove this oddity by just
499 : // changing the output names to include the arch, which would also fix
500 : // -save-temps. Compatibility wins for now.
501 :
4: branch 1 taken
54: branch 2 taken
0: branch 5 not taken
4: branch 6 taken
0: branch 7 not taken
58: branch 8 taken
502 58: if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
503 : Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
504 0: << types::getTypeName(Act->getType());
505 :
506 58: ActionList Inputs;
62: branch 1 taken
58: branch 2 taken
507 120: for (unsigned i = 0, e = Archs.size(); i != e; ++i)
508 62: Inputs.push_back(new BindArchAction(Act, Archs[i]));
509 :
510 : // Lipo if necessary, we do it this way because we need to set the arch flag
511 : // so that -Xarch_ gets overwritten.
4: branch 1 taken
54: branch 2 taken
0: branch 4 not taken
4: branch 5 taken
54: branch 6 taken
4: branch 7 taken
512 58: if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
513 54: Actions.append(Inputs.begin(), Inputs.end());
514 : else
515 4: Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
516 60: }
517 60: }
518 :
519 240: void Driver::BuildActions(const ArgList &Args, ActionList &Actions) const {
520 240: llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
521 : // Start by constructing the list of inputs and their types.
522 :
523 : // Track the current user specified (-x) input. We also explicitly track the
524 : // argument used to set the type; we only want to claim the type when we
525 : // actually use it, so we warn about unused -x arguments.
526 240: types::ID InputType = types::TY_Nothing;
527 240: Arg *InputTypeArg = 0;
528 :
529 240: llvm::SmallVector<std::pair<types::ID, const Arg*>, 16> Inputs;
1401: branch 2 taken
240: branch 3 taken
530 1641: for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
531 : it != ie; ++it) {
532 1401: Arg *A = *it;
533 :
234: branch 2 taken
1167: branch 3 taken
534 1401: if (isa<InputOption>(A->getOption())) {
535 234: const char *Value = A->getValue(Args);
536 234: types::ID Ty = types::TY_INVALID;
537 :
538 : // Infer the input type if necessary.
199: branch 0 taken
35: branch 1 taken
539 234: if (InputType == types::TY_Nothing) {
540 : // If there was an explicit arg for this, claim it.
1: branch 0 taken
198: branch 1 taken
541 199: if (InputTypeArg)
542 1: InputTypeArg->claim();
543 :
544 : // stdin must be handled specially.
0: branch 1 not taken
199: branch 2 taken
545 199: if (memcmp(Value, "-", 2) == 0) {
546 : // If running with -E, treat as a C input (this changes the builtin
547 : // macros, for example). This may be overridden by -ObjC below.
548 : //
549 : // Otherwise emit an error but still use a valid type to avoid
550 : // spurious errors (e.g., no inputs).
0: branch 2 not taken
0: branch 3 not taken
551 0: if (!Args.hasArgNoClaim(options::OPT_E))
552 0: Diag(clang::diag::err_drv_unknown_stdin_type);
553 0: Ty = types::TY_C;
554 : } else {
555 : // Otherwise lookup by extension, and fallback to ObjectType if not
556 : // found. We use a host hook here because Darwin at least has its own
557 : // idea of what .s is.
199: branch 1 taken
0: branch 2 not taken
558 199: if (const char *Ext = strrchr(Value, '.'))
559 199: Ty = Host->lookupTypeForExtension(Ext + 1);
560 :
6: branch 0 taken
193: branch 1 taken
561 199: if (Ty == types::TY_INVALID)
562 6: Ty = types::TY_Object;
563 : }
564 :
565 : // -ObjC and -ObjC++ override the default language, but only for "source
566 : // files". We just treat everything that isn't a linker input as a
567 : // source file.
568 : //
569 : // FIXME: Clean this up if we move the phase sequence into the type.
193: branch 0 taken
6: branch 1 taken
570 199: if (Ty != types::TY_Object) {
0: branch 2 not taken
193: branch 3 taken
571 193: if (Args.hasArg(options::OPT_ObjC))
572 0: Ty = types::TY_ObjC;
0: branch 2 not taken
193: branch 3 taken
573 193: else if (Args.hasArg(options::OPT_ObjCXX))
574 0: Ty = types::TY_ObjCXX;
575 : }
576 : } else {
0: branch 0 not taken
35: branch 1 taken
577 35: assert(InputTypeArg && "InputType set w/o InputTypeArg");
578 35: InputTypeArg->claim();
579 35: Ty = InputType;
580 : }
581 :
582 : // Check that the file exists, if enabled.
225: branch 0 taken
9: branch 1 taken
223: branch 3 taken
2: branch 4 taken
0: branch 8 not taken
223: branch 9 taken
223: branch 10 taken
11: branch 11 taken
0: branch 13 not taken
234: branch 14 taken
583 234: if (CheckInputsExist && memcmp(Value, "-", 2) != 0 &&
584 : !llvm::sys::Path(Value).exists())
585 0: Diag(clang::diag::err_drv_no_such_file) << A->getValue(Args);
586 : else
587 234: Inputs.push_back(std::make_pair(Ty, A));
588 :
7: branch 2 taken
1160: branch 3 taken
589 1167: } else if (A->getOption().isLinkerInput()) {
590 : // Just treat as object type, we could make a special type for this if
591 : // necessary.
592 7: Inputs.push_back(std::make_pair(types::TY_Object, A));
593 :
37: branch 3 taken
1123: branch 4 taken
594 1160: } else if (A->getOption().matches(options::OPT_x)) {
595 37: InputTypeArg = A;
596 37: InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args));
597 :
598 : // Follow gcc behavior and treat as linker input for invalid -x
599 : // options. Its not clear why we shouldn't just revert to unknown; but
600 : // this isn't very important, we might as well be bug comatible.
0: branch 0 not taken
37: branch 1 taken
601 37: if (!InputType) {
602 0: Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args);
603 0: InputType = types::TY_Object;
604 : }
605 : }
606 : }
607 :
186: branch 0 taken
54: branch 1 taken
2: branch 3 taken
184: branch 4 taken
2: branch 5 taken
238: branch 6 taken
608 240: if (!SuppressMissingInputWarning && Inputs.empty()) {
609 2: Diag(clang::diag::err_drv_no_input_files);
610 2: return;
611 : }
612 :
613 : // Determine which compilation mode we are in. We look for options which
614 : // affect the phase, starting with the earliest phases, and record which
615 : // option we used to determine the final phase.
616 238: Arg *FinalPhaseArg = 0;
617 : phases::ID FinalPhase;
618 :
619 : // -{E,M,MM} only run the preprocessor.
198: branch 2 taken
40: branch 3 taken
197: branch 6 taken
1: branch 7 taken
0: branch 10 not taken
197: branch 11 taken
41: branch 12 taken
197: branch 13 taken
620 238: if ((FinalPhaseArg = Args.getLastArg(options::OPT_E)) ||
621 : (FinalPhaseArg = Args.getLastArg(options::OPT_M)) ||
622 : (FinalPhaseArg = Args.getLastArg(options::OPT_MM))) {
623 41: FinalPhase = phases::Preprocess;
624 :
625 : // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
111: branch 2 taken
86: branch 3 taken
109: branch 7 taken
2: branch 8 taken
105: branch 11 taken
4: branch 12 taken
48: branch 15 taken
57: branch 16 taken
140: branch 17 taken
57: branch 18 taken
626 197: } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) ||
627 : (FinalPhaseArg = Args.getLastArg(options::OPT__analyze,
628 : options::OPT__analyze_auto)) ||
629 : (FinalPhaseArg = Args.getLastArg(options::OPT_emit_ast)) ||
630 : (FinalPhaseArg = Args.getLastArg(options::OPT_S))) {
631 140: FinalPhase = phases::Compile;
632 :
633 : // -c only runs up to the assembler.
17: branch 2 taken
40: branch 3 taken
634 57: } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_c))) {
635 17: FinalPhase = phases::Assemble;
636 :
637 : // Otherwise do everything.
638 : } else
639 40: FinalPhase = phases::Link;
640 :
641 : // Reject -Z* at the top level, these options should never have been exposed
642 : // by gcc.
0: branch 2 not taken
238: branch 3 taken
643 238: if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
644 0: Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
645 :
646 : // Construct the actions to perform.
647 238: ActionList LinkerInputs;
241: branch 2 taken
238: branch 3 taken
648 479: for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
649 241: types::ID InputType = Inputs[i].first;
650 241: const Arg *InputArg = Inputs[i].second;
651 :
652 241: unsigned NumSteps = types::getNumCompilationPhases(InputType);
0: branch 0 not taken
241: branch 1 taken
653 241: assert(NumSteps && "Invalid number of steps!");
654 :
655 : // If the first step comes after the final phase we are doing as part of
656 : // this compilation, warn the user about it.
657 241: phases::ID InitialPhase = types::getCompilationPhase(InputType, 0);
0: branch 0 not taken
241: branch 1 taken
658 241: if (InitialPhase > FinalPhase) {
659 : // Claim here to avoid the more general unused warning.
660 0: InputArg->claim();
661 :
662 : // Special case '-E' warning on a previously preprocessed file to make
663 : // more sense.
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
664 0: if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess &&
665 : getPreprocessedType(InputType) == types::TY_INVALID)
666 : Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
667 : << InputArg->getAsString(Args)
668 0: << FinalPhaseArg->getOption().getName();
669 : else
670 : Diag(clang::diag::warn_drv_input_file_unused)
671 : << InputArg->getAsString(Args)
672 : << getPhaseName(InitialPhase)
673 0: << FinalPhaseArg->getOption().getName();
674 0: continue;
675 : }
676 :
677 : // Build the pipeline for this file.
678 241: llvm::OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
576: branch 0 taken
6: branch 1 taken
679 582: for (unsigned i = 0; i != NumSteps; ++i) {
680 576: phases::ID Phase = types::getCompilationPhase(InputType, i);
681 :
682 : // We are done if this step is past what the user requested.
112: branch 0 taken
464: branch 1 taken
683 576: if (Phase > FinalPhase)
684 112: break;
685 :
686 : // Queue linker inputs.
37: branch 0 taken
427: branch 1 taken
687 464: if (Phase == phases::Link) {
0: branch 0 not taken
37: branch 1 taken
688 37: assert(i + 1 == NumSteps && "linking must be final compilation step.");
689 37: LinkerInputs.push_back(Current.take());
690 37: break;
691 : }
692 :
693 : // Some types skip the assembler phase (e.g., llvm-bc), but we can't
694 : // encode this in the steps because the intermediate type depends on
695 : // arguments. Just special case here.
41: branch 0 taken
386: branch 1 taken
5: branch 4 taken
36: branch 5 taken
5: branch 6 taken
422: branch 7 taken
696 427: if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
697 5: continue;
698 :
699 : // Otherwise construct the appropriate action.
700 422: Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
86: branch 2 taken
336: branch 3 taken
701 422: if (Current->getType() == types::TY_Nothing)
702 86: break;
703 : }
704 :
705 : // If we ended with something, add to the output list.
204: branch 1 taken
37: branch 2 taken
706 241: if (Current)
707 204: Actions.push_back(Current.take());
708 : }
709 :
710 : // Add a link action if necessary.
31: branch 1 taken
207: branch 2 taken
711 238: if (!LinkerInputs.empty())
712 31: Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
713 :
714 : // If we are linking, claim any options which are obviously only used for
715 : // compilation.
40: branch 0 taken
198: branch 1 taken
716 238: if (FinalPhase == phases::Link)
238: branch 4 taken
2: branch 5 taken
238: branch 7 taken
2: branch 8 taken
717 40: Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
718 : }
719 :
720 : Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
721 422: Action *Input) const {
722 422: llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
723 : // Build the appropriate action.
0: branch 0 not taken
213: branch 1 taken
6: branch 2 taken
167: branch 3 taken
36: branch 4 taken
0: branch 5 not taken
724 422: switch (Phase) {
725 0: case phases::Link: assert(0 && "link action invalid here.");
726 : case phases::Preprocess: {
727 : types::ID OutputTy;
728 : // -{M, MM} alter the output type.
212: branch 2 taken
1: branch 3 taken
0: branch 6 not taken
212: branch 7 taken
1: branch 8 taken
212: branch 9 taken
729 213: if (Args.hasArg(options::OPT_M) || Args.hasArg(options::OPT_MM)) {
730 1: OutputTy = types::TY_Dependencies;
731 : } else {
732 212: OutputTy = types::getPreprocessedType(Input->getType());
733 : assert(OutputTy != types::TY_INVALID &&
0: branch 0 not taken
212: branch 1 taken
734 212: "Cannot preprocess this input type!");
735 : }
736 213: return new PreprocessJobAction(Input, OutputTy);
737 : }
738 : case phases::Precompile:
739 6: return new PrecompileJobAction(Input, types::TY_PCH);
740 : case phases::Compile: {
741 167: bool HasO4 = false;
7: branch 2 taken
160: branch 3 taken
742 167: if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
743 7: HasO4 = A->getOption().matches(options::OPT_O4);
744 :
86: branch 2 taken
81: branch 3 taken
745 167: if (Args.hasArg(options::OPT_fsyntax_only)) {
746 86: return new CompileJobAction(Input, types::TY_Nothing);
2: branch 3 taken
79: branch 4 taken
747 81: } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
748 2: return new AnalyzeJobAction(Input, types::TY_Plist);
4: branch 2 taken
75: branch 3 taken
749 79: } else if (Args.hasArg(options::OPT_emit_ast)) {
750 4: return new CompileJobAction(Input, types::TY_AST);
50: branch 2 taken
25: branch 3 taken
48: branch 6 taken
2: branch 7 taken
1: branch 8 taken
47: branch 9 taken
28: branch 10 taken
47: branch 11 taken
751 75: } else if (Args.hasArg(options::OPT_emit_llvm) ||
752 : Args.hasArg(options::OPT_flto) || HasO4) {
753 : types::ID Output =
23: branch 2 taken
5: branch 3 taken
754 28: Args.hasArg(options::OPT_S) ? types::TY_LLVMAsm : types::TY_LLVMBC;
755 28: return new CompileJobAction(Input, Output);
756 : } else {
757 47: return new CompileJobAction(Input, types::TY_PP_Asm);
758 : }
759 : }
760 : case phases::Assemble:
761 36: return new AssembleJobAction(Input, types::TY_Object);
762 : }
763 :
764 0: assert(0 && "invalid phase in ConstructPhaseAction");
765 422: return 0;
766 : }
767 :
768 223: void Driver::BuildJobs(Compilation &C) const {
769 223: llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
770 223: bool SaveTemps = C.getArgs().hasArg(options::OPT_save_temps);
771 223: bool UsePipes = C.getArgs().hasArg(options::OPT_pipe);
772 :
773 : // FIXME: Pipes are forcibly disabled until we support executing them.
208: branch 0 taken
15: branch 1 taken
774 223: if (!CCCPrintBindings)
775 208: UsePipes = false;
776 :
777 : // -save-temps inhibits pipes.
4: branch 0 taken
219: branch 1 taken
0: branch 2 not taken
4: branch 3 taken
778 223: if (SaveTemps && UsePipes)
779 0: Diag(clang::diag::warn_drv_pipe_ignored_with_save_temps);
780 :
781 223: Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
782 :
783 : // It is an error to provide a -o option if we are making multiple output
784 : // files.
71: branch 0 taken
152: branch 1 taken
785 223: if (FinalOutput) {
786 71: unsigned NumOutputs = 0;
71: branch 2 taken
71: branch 3 taken
787 213: for (ActionList::const_iterator it = C.getActions().begin(),
788 71: ie = C.getActions().end(); it != ie; ++it)
71: branch 1 taken
0: branch 2 not taken
789 71: if ((*it)->getType() != types::TY_Nothing)
790 71: ++NumOutputs;
791 :
0: branch 0 not taken
71: branch 1 taken
792 71: if (NumOutputs > 1) {
793 0: Diag(clang::diag::err_drv_output_argument_with_multiple_files);
794 0: FinalOutput = 0;
795 : }
796 : }
797 :
218: branch 2 taken
223: branch 3 taken
798 664: for (ActionList::const_iterator it = C.getActions().begin(),
799 223: ie = C.getActions().end(); it != ie; ++it) {
800 218: Action *A = *it;
801 :
802 : // If we are linking an image for multiple archs then the linker wants
803 : // -arch_multiple and -final_output <final image name>. Unfortunately, this
804 : // doesn't fit in cleanly because we have to pass this information down.
805 : //
806 : // FIXME: This is a hack; find a cleaner way to integrate this into the
807 : // process.
808 218: const char *LinkingOutput = 0;
2: branch 1 taken
216: branch 2 taken
809 218: if (isa<LipoJobAction>(A)) {
1: branch 0 taken
1: branch 1 taken
810 2: if (FinalOutput)
811 1: LinkingOutput = FinalOutput->getValue(C.getArgs());
812 : else
813 1: LinkingOutput = DefaultImageName.c_str();
814 : }
815 :
816 218: InputInfo II;
817 : BuildJobsForAction(C, A, &C.getDefaultToolChain(),
818 : /*BoundArch*/0,
819 : /*CanAcceptPipe*/ true,
820 : /*AtTopLevel*/ true,
821 : /*LinkingOutput*/ LinkingOutput,
822 218: II);
823 : }
824 :
825 : // If the user passed -Qunused-arguments or there were errors, don't warn
826 : // about any unused arguments.
216: branch 1 taken
7: branch 2 taken
0: branch 6 not taken
216: branch 7 taken
7: branch 8 taken
216: branch 9 taken
827 223: if (Diags.getNumErrors() ||
828 : C.getArgs().hasArg(options::OPT_Qunused_arguments))
829 7: return;
830 :
831 : // Claim -### here.
832 216: (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
833 :
1202: branch 4 taken
216: branch 5 taken
834 1418: for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
835 : it != ie; ++it) {
836 1202: Arg *A = *it;
837 :
838 : // FIXME: It would be nice to be able to send the argument to the
839 : // Diagnostic, so that extra values, position, and so on could be printed.
29: branch 1 taken
1173: branch 2 taken
840 1202: if (!A->isClaimed()) {
2: branch 2 taken
27: branch 3 taken
841 29: if (A->getOption().hasNoArgumentUnused())
842 2: continue;
843 :
844 : // Suppress the warning automatically if this is just a flag, and it is an
845 : // instance of an argument we already claimed.
846 27: const Option &Opt = A->getOption();
18: branch 1 taken
9: branch 2 taken
847 27: if (isa<FlagOption>(Opt)) {
848 18: bool DuplicateClaimed = false;
849 :
23: branch 7 taken
13: branch 8 taken
850 54: for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
851 18: ie = C.getArgs().filtered_end(); it != ie; ++it) {
5: branch 2 taken
18: branch 3 taken
852 23: if ((*it)->isClaimed()) {
853 5: DuplicateClaimed = true;
854 5: break;
855 : }
856 : }
857 :
5: branch 0 taken
13: branch 1 taken
858 18: if (DuplicateClaimed)
859 5: continue;
860 : }
861 :
862 : Diag(clang::diag::warn_drv_unused_argument)
863 22: << A->getAsString(C.getArgs());
864 : }
216: branch 1 taken
7: branch 2 taken
865 223: }
866 : }
867 :
868 : static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC,
869 : const JobAction *JA,
870 263: const ActionList *&Inputs) {
871 263: const Tool *ToolForJob = 0;
872 :
873 : // See if we should look for a compiler with an integrated assembler. We match
874 : // bottom up, so what we are actually looking for is an assembler job with a
875 : // compiler input.
0: branch 6 not taken
263: branch 7 taken
0: branch 11 not taken
0: branch 12 not taken
0: branch 14 not taken
0: branch 15 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 23 not taken
263: branch 24 taken
876 263: if (C.getArgs().hasArg(options::OPT_integrated_as,
877 : options::OPT_no_integrated_as,
878 : TC->IsIntegratedAssemblerDefault()) &&
879 : !C.getArgs().hasArg(options::OPT_save_temps) &&
880 : isa<AssembleJobAction>(JA) &&
881 : Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
882 0: const Tool &Compiler = TC->SelectTool(C,cast<JobAction>(**Inputs->begin()));
0: branch 1 not taken
0: branch 2 not taken
883 0: if (Compiler.hasIntegratedAssembler()) {
884 0: Inputs = &(*Inputs)[0]->getInputs();
885 0: ToolForJob = &Compiler;
886 : }
887 : }
888 :
889 : // Otherwise use the tool for the current job.
263: branch 0 taken
0: branch 1 not taken
890 263: if (!ToolForJob)
891 263: ToolForJob = &TC->SelectTool(C, *JA);
892 :
893 : // See if we should use an integrated preprocessor. We do so when we have
894 : // exactly one input, since this is the only use case we care about
895 : // (irrelevant since we don't support combine yet).
260: branch 1 taken
3: branch 2 taken
159: branch 5 taken
101: branch 6 taken
156: branch 10 taken
3: branch 11 taken
156: branch 15 taken
0: branch 16 not taken
152: branch 20 taken
4: branch 21 taken
152: branch 23 taken
0: branch 24 not taken
152: branch 25 taken
111: branch 26 taken
896 263: if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
897 : !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
898 : !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
899 : !C.getArgs().hasArg(options::OPT_save_temps) &&
900 : ToolForJob->hasIntegratedCPP())
901 152: Inputs = &(*Inputs)[0]->getInputs();
902 :
903 263: return *ToolForJob;
904 : }
905 :
906 : void Driver::BuildJobsForAction(Compilation &C,
907 : const Action *A,
908 : const ToolChain *TC,
909 : const char *BoundArch,
910 : bool CanAcceptPipe,
911 : bool AtTopLevel,
912 : const char *LinkingOutput,
913 537: InputInfo &Result) const {
914 537: llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
915 :
916 537: bool UsePipes = C.getArgs().hasArg(options::OPT_pipe);
917 : // FIXME: Pipes are forcibly disabled until we support executing them.
491: branch 0 taken
46: branch 1 taken
918 537: if (!CCCPrintBindings)
919 491: UsePipes = false;
920 :
221: branch 1 taken
316: branch 2 taken
921 537: if (const InputAction *IA = dyn_cast<InputAction>(A)) {
922 : // FIXME: It would be nice to not claim this here; maybe the old scheme of
923 : // just using Args was better?
924 221: const Arg &Input = IA->getInputArg();
925 221: Input.claim();
214: branch 1 taken
7: branch 2 taken
926 221: if (isa<PositionalArg>(Input)) {
927 214: const char *Name = Input.getValue(C.getArgs());
928 214: Result = InputInfo(Name, A->getType(), Name);
929 : } else
930 7: Result = InputInfo(&Input, A->getType(), "");
931 274: return;
932 : }
933 :
53: branch 1 taken
263: branch 2 taken
934 316: if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
935 53: const ToolChain *TC = &C.getDefaultToolChain();
936 :
937 53: std::string Arch;
17: branch 1 taken
36: branch 2 taken
938 53: if (BAA->getArchName())
939 17: TC = Host->CreateToolChain(C.getArgs(), BAA->getArchName());
940 :
941 : BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
942 53: CanAcceptPipe, AtTopLevel, LinkingOutput, Result);
943 53: return;
944 : }
945 :
946 263: const ActionList *Inputs = &A->getInputs();
947 :
948 263: const JobAction *JA = cast<JobAction>(A);
949 263: const Tool &T = SelectToolForJob(C, TC, JA, Inputs);
950 :
951 : // Only use pipes when there is exactly one input.
260: branch 1 taken
3: branch 2 taken
234: branch 4 taken
26: branch 5 taken
952 263: bool TryToUsePipeInput = Inputs->size() == 1 && T.acceptsPipedInput();
953 263: InputInfoList InputInfos;
266: branch 2 taken
263: branch 3 taken
954 529: for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
955 : it != ie; ++it) {
956 266: InputInfo II;
957 : BuildJobsForAction(C, *it, TC, BoundArch, TryToUsePipeInput,
958 266: /*AtTopLevel*/false, LinkingOutput, II);
959 266: InputInfos.push_back(II);
960 : }
961 :
962 : // Determine if we should output to a pipe.
963 263: bool OutputToPipe = false;
244: branch 0 taken
19: branch 1 taken
212: branch 3 taken
32: branch 4 taken
212: branch 5 taken
51: branch 6 taken
964 263: if (CanAcceptPipe && T.canPipeOutput()) {
965 : // Some actions default to writing to a pipe if they are the top level phase
966 : // and there was no user override.
967 : //
968 : // FIXME: Is there a better way to handle this?
186: branch 0 taken
26: branch 1 taken
969 212: if (AtTopLevel) {
41: branch 1 taken
145: branch 2 taken
12: branch 6 taken
29: branch 7 taken
12: branch 8 taken
174: branch 9 taken
970 186: if (isa<PreprocessJobAction>(A) && !C.getArgs().hasArg(options::OPT_o))
971 12: OutputToPipe = true;
2: branch 0 taken
24: branch 1 taken
972 26: } else if (UsePipes)
973 2: OutputToPipe = true;
974 : }
975 :
976 : // Figure out where to put the job (pipes).
977 263: Job *Dest = &C.getJobs();
2: branch 2 taken
261: branch 3 taken
978 263: if (InputInfos[0].isPipe()) {
0: branch 0 not taken
2: branch 1 taken
979 2: assert(TryToUsePipeInput && "Unrequested pipe!");
2: branch 1 taken
0: branch 2 not taken
980 2: assert(InputInfos.size() == 1 && "Unexpected pipe with multiple inputs.");
981 2: Dest = &InputInfos[0].getPipe();
982 : }
983 :
984 : // Always use the first input as the base input.
985 263: const char *BaseInput = InputInfos[0].getBaseInput();
986 :
987 : // Determine the place to write output to (nothing, pipe, or filename) and
988 : // where to put the new job.
86: branch 1 taken
177: branch 2 taken
989 263: if (JA->getType() == types::TY_Nothing) {
990 86: Result = InputInfo(A->getType(), BaseInput);
14: branch 0 taken
163: branch 1 taken
991 177: } else if (OutputToPipe) {
992 : // Append to current piped job or create a new one as appropriate.
993 14: PipedJob *PJ = dyn_cast<PipedJob>(Dest);
13: branch 0 taken
1: branch 1 taken
994 14: if (!PJ) {
995 13: PJ = new PipedJob();
996 : // FIXME: Temporary hack so that -ccc-print-bindings work until we have
997 : // pipe support. Please remove later.
12: branch 0 taken
1: branch 1 taken
998 13: if (!CCCPrintBindings)
999 12: cast<JobList>(Dest)->addJob(PJ);
1000 13: Dest = PJ;
1001 : }
1002 14: Result = InputInfo(PJ, A->getType(), BaseInput);
1003 : } else {
1004 : Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel),
1005 163: A->getType(), BaseInput);
1006 : }
1007 :
28: branch 0 taken
235: branch 1 taken
1008 263: if (CCCPrintBindings) {
1009 : llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"'
1010 28: << " - \"" << T.getName() << "\", inputs: [";
28: branch 1 taken
28: branch 2 taken
1011 56: for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1012 28: llvm::errs() << InputInfos[i].getAsString();
0: branch 0 not taken
28: branch 1 taken
1013 28: if (i + 1 != e)
1014 0: llvm::errs() << ", ";
1015 : }
1016 28: llvm::errs() << "], output: " << Result.getAsString() << "\n";
1017 : } else {
1018 : T.ConstructJob(C, *JA, *Dest, Result, InputInfos,
1019 235: C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
263: branch 2 taken
274: branch 3 taken
1020 263: }
1021 : }
1022 :
1023 : const char *Driver::GetNamedOutputPath(Compilation &C,
1024 : const JobAction &JA,
1025 : const char *BaseInput,
1026 163: bool AtTopLevel) const {
1027 163: llvm::PrettyStackTraceString CrashInfo("Computing output path");
1028 : // Output to a user requested destination?
120: branch 0 taken
43: branch 1 taken
1029 163: if (AtTopLevel) {
71: branch 3 taken
49: branch 4 taken
1030 120: if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1031 71: return C.addResultFile(FinalOutput->getValue(C.getArgs()));
1032 : }
1033 :
1034 : // Output to a temporary file?
43: branch 0 taken
49: branch 1 taken
38: branch 5 taken
5: branch 6 taken
38: branch 7 taken
54: branch 8 taken
1035 92: if (!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) {
1036 : std::string TmpName =
1037 38: GetTemporaryPath(types::getTypeTempSuffix(JA.getType()));
1038 38: return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1039 : }
1040 :
1041 54: llvm::sys::Path BasePath(BaseInput);
1042 54: std::string BaseName(BasePath.getLast());
1043 :
1044 : // Determine what the derived output name should be.
1045 : const char *NamedOutput;
23: branch 1 taken
31: branch 2 taken
1046 54: if (JA.getType() == types::TY_Image) {
1047 23: NamedOutput = DefaultImageName.c_str();
1048 : } else {
1049 31: const char *Suffix = types::getTypeTempSuffix(JA.getType());
0: branch 0 not taken
31: branch 1 taken
1050 31: assert(Suffix && "All types used for output should have a suffix.");
1051 :
1052 31: std::string::size_type End = std::string::npos;
29: branch 2 taken
2: branch 3 taken
1053 31: if (!types::appendSuffixForType(JA.getType()))
1054 29: End = BaseName.rfind('.');
1055 31: std::string Suffixed(BaseName.substr(0, End));
1056 31: Suffixed += '.';
1057 31: Suffixed += Suffix;
1058 31: NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1059 : }
1060 :
1061 : // As an annoying special case, PCH generation doesn't strip the pathname.
2: branch 1 taken
52: branch 2 taken
1062 54: if (JA.getType() == types::TY_PCH) {
1063 2: BasePath.eraseComponent();
0: branch 1 not taken
2: branch 2 taken
1064 2: if (BasePath.isEmpty())
1065 0: BasePath = NamedOutput;
1066 : else
1067 2: BasePath.appendComponent(NamedOutput);
1068 2: return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()));
1069 : } else {
1070 52: return C.addResultFile(NamedOutput);
1071 54: }
1072 : }
1073 :
1074 13: std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
1075 13: const ToolChain::path_list &List = TC.getFilePaths();
22: branch 1 taken
6: branch 2 taken
28: branch 3 taken
7: branch 4 taken
1076 76: for (ToolChain::path_list::const_iterator
1077 13: it = List.begin(), ie = List.end(); it != ie; ++it) {
1078 28: llvm::sys::Path P(*it);
1079 28: P.appendComponent(Name);
6: branch 1 taken
22: branch 2 taken
1080 28: if (P.exists())
1081 12: return P.str();
1082 : }
1083 :
1084 7: return Name;
1085 : }
1086 :
1087 : std::string Driver::GetProgramPath(const char *Name, const ToolChain &TC,
1088 237: bool WantFile) const {
1089 237: const ToolChain::path_list &List = TC.getProgramPaths();
166: branch 1 taken
179: branch 2 taken
345: branch 3 taken
58: branch 4 taken
1090 985: for (ToolChain::path_list::const_iterator
1091 237: it = List.begin(), ie = List.end(); it != ie; ++it) {
1092 345: llvm::sys::Path P(*it);
1093 345: P.appendComponent(Name);
0: branch 0 not taken
345: branch 1 taken
179: branch 4 taken
166: branch 5 taken
1094 345: if (WantFile ? P.exists() : P.canExecute())
1095 358: return P.str();
1096 : }
1097 :
1098 : // If all else failed, search the path.
1099 58: llvm::sys::Path P(llvm::sys::Program::FindProgramByName(Name));
51: branch 1 taken
7: branch 2 taken
1100 58: if (!P.empty())
1101 51: return P.str();
1102 :
1103 7: return Name;
1104 : }
1105 :
1106 38: std::string Driver::GetTemporaryPath(const char *Suffix) const {
1107 : // FIXME: This is lame; sys::Path should provide this function (in particular,
1108 : // it should know how to find the temporary files dir).
1109 38: std::string Error;
1110 38: const char *TmpDir = ::getenv("TMPDIR");
38: branch 0 taken
0: branch 1 not taken
1111 38: if (!TmpDir)
1112 38: TmpDir = ::getenv("TEMP");
38: branch 0 taken
0: branch 1 not taken
1113 38: if (!TmpDir)
1114 38: TmpDir = ::getenv("TMP");
38: branch 0 taken
0: branch 1 not taken
1115 38: if (!TmpDir)
1116 38: TmpDir = "/tmp";
1117 38: llvm::sys::Path P(TmpDir);
1118 38: P.appendComponent("cc");
0: branch 1 not taken
38: branch 2 taken
1119 38: if (P.makeUnique(false, &Error)) {
1120 0: Diag(clang::diag::err_drv_unable_to_make_temp) << Error;
1121 0: return "";
1122 : }
1123 :
1124 : // FIXME: Grumble, makeUnique sometimes leaves the file around!? PR3837.
1125 38: P.eraseFromDisk(false, 0);
1126 :
1127 38: P.appendSuffix(Suffix);
1128 38: return P.str();
1129 : }
1130 :
1131 248: const HostInfo *Driver::GetHostInfo(const char *TripleStr) const {
1132 248: llvm::PrettyStackTraceString CrashInfo("Constructing host");
1133 248: llvm::Triple Triple(TripleStr);
1134 :
0: branch 1 not taken
60: branch 2 taken
1: branch 3 taken
1: branch 4 taken
1: branch 5 taken
152: branch 6 taken
33: branch 7 taken
1135 248: switch (Triple.getOS()) {
1136 : case llvm::Triple::AuroraUX:
1137 0: return createAuroraUXHostInfo(*this, Triple);
1138 : case llvm::Triple::Darwin:
1139 60: return createDarwinHostInfo(*this, Triple);
1140 : case llvm::Triple::DragonFly:
1141 1: return createDragonFlyHostInfo(*this, Triple);
1142 : case llvm::Triple::OpenBSD:
1143 1: return createOpenBSDHostInfo(*this, Triple);
1144 : case llvm::Triple::FreeBSD:
1145 1: return createFreeBSDHostInfo(*this, Triple);
1146 : case llvm::Triple::Linux:
1147 152: return createLinuxHostInfo(*this, Triple);
1148 : default:
1149 33: return createUnknownHostInfo(*this, Triple);
1150 248: }
1151 : }
1152 :
1153 : bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
1154 266: const llvm::Triple &Triple) const {
1155 : // Check if user requested no clang, or clang doesn't understand this type (we
1156 : // only handle single inputs for now).
250: branch 0 taken
16: branch 1 taken
247: branch 3 taken
3: branch 4 taken
45: branch 8 taken
202: branch 9 taken
64: branch 10 taken
202: branch 11 taken
1157 266: if (!CCCUseClang || JA.size() != 1 ||
1158 : !types::isAcceptedByClang((*JA.begin())->getType()))
1159 64: return false;
1160 :
1161 : // Otherwise make sure this is an action clang understands.
45: branch 1 taken
157: branch 2 taken
1162 202: if (isa<PreprocessJobAction>(JA)) {
1: branch 0 taken
44: branch 1 taken
1163 45: if (!CCCUseClangCPP) {
1164 1: Diag(clang::diag::warn_drv_not_using_clang_cpp);
1165 1: return false;
1166 : }
153: branch 1 taken
4: branch 2 taken
1: branch 4 taken
152: branch 5 taken
1: branch 6 taken
156: branch 7 taken
1167 157: } else if (!isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA))
1168 1: return false;
1169 :
1170 : // Use clang for C++?
1: branch 0 taken
199: branch 1 taken
1: branch 5 taken
0: branch 6 not taken
1: branch 7 taken
199: branch 8 taken
1171 200: if (!CCCUseClangCXX && types::isCXX((*JA.begin())->getType())) {
1172 1: Diag(clang::diag::warn_drv_not_using_clang_cxx);
1173 1: return false;
1174 : }
1175 :
1176 : // Always use clang for precompiling and AST generation, regardless of archs.
195: branch 1 taken
4: branch 2 taken
3: branch 4 taken
192: branch 5 taken
7: branch 6 taken
192: branch 7 taken
1177 199: if (isa<PrecompileJobAction>(JA) || JA.getType() == types::TY_AST)
1178 7: return true;
1179 :
1180 : // Finally, don't use clang if this isn't one of the user specified archs to
1181 : // build.
3: branch 1 taken
189: branch 2 taken
2: branch 5 taken
1: branch 6 taken
2: branch 7 taken
190: branch 8 taken
1182 192: if (!CCCClangArchs.empty() && !CCCClangArchs.count(Triple.getArch())) {
1183 2: Diag(clang::diag::warn_drv_not_using_clang_arch) << Triple.getArchName();
1184 2: return false;
1185 : }
1186 :
1187 190: return true;
1188 : }
1189 :
1190 : /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
1191 : /// grouped values as integers. Numbers which are not provided are set to 0.
1192 : ///
1193 : /// \return True if the entire string was parsed (9.2), or all groups were
1194 : /// parsed (10.3.5extrastuff).
1195 : bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
1196 : unsigned &Minor, unsigned &Micro,
1197 112: bool &HadExtra) {
1198 112: HadExtra = false;
1199 :
1200 112: Major = Minor = Micro = 0;
0: branch 0 not taken
112: branch 1 taken
1201 112: if (*Str == '\0')
1202 0: return true;
1203 :
1204 : char *End;
1205 112: Major = (unsigned) strtol(Str, &End, 10);
112: branch 0 taken
0: branch 1 not taken
60: branch 2 taken
52: branch 3 taken
1206 112: if (*Str != '\0' && *End == '\0')
1207 60: return true;
0: branch 0 not taken
52: branch 1 taken
1208 52: if (*End != '.')
1209 0: return false;
1210 :
1211 52: Str = End+1;
1212 52: Minor = (unsigned) strtol(Str, &End, 10);
52: branch 0 taken
0: branch 1 not taken
21: branch 2 taken
31: branch 3 taken
1213 52: if (*Str != '\0' && *End == '\0')
1214 21: return true;
0: branch 0 not taken
31: branch 1 taken
1215 31: if (*End != '.')
1216 0: return false;
1217 :
1218 31: Str = End+1;
1219 31: Micro = (unsigned) strtol(Str, &End, 10);
31: branch 0 taken
0: branch 1 not taken
31: branch 2 taken
0: branch 3 not taken
1220 31: if (*Str != '\0' && *End == '\0')
1221 31: return true;
0: branch 0 not taken
0: branch 1 not taken
1222 0: if (Str == End)
1223 0: return false;
1224 0: HadExtra = true;
1225 0: return true;
1226 : }
Generated: 2010-02-10 01:31 by zcov