 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
34.3% |
85 / 248 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
49.2% |
122 / 248 |
| |
|
Line Coverage: |
86.0% |
178 / 207 |
| |
 |
|
 |
1 : //===--- HostInfo.cpp - Host specific information -----------------------*-===//
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/HostInfo.h"
11 :
12 : #include "clang/Driver/Arg.h"
13 : #include "clang/Driver/ArgList.h"
14 : #include "clang/Driver/Driver.h"
15 : #include "clang/Driver/DriverDiagnostic.h"
16 : #include "clang/Driver/Option.h"
17 : #include "clang/Driver/Options.h"
18 :
19 : #include "llvm/ADT/StringMap.h"
20 : #include "llvm/Support/Compiler.h"
21 :
22 : #include "ToolChains.h"
23 :
24 : #include <cassert>
25 :
26 : using namespace clang::driver;
27 :
28 248: HostInfo::HostInfo(const Driver &D, const llvm::Triple &_Triple)
29 248: : TheDriver(D), Triple(_Triple) {
30 248: }
31 :
32 248: HostInfo::~HostInfo() {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
248: branch 10 taken
33 248: }
34 :
35 : namespace {
36 :
37 : // Darwin Host Info
38 :
39 : /// DarwinHostInfo - Darwin host information implementation.
40 : class DarwinHostInfo : public HostInfo {
41 : /// Darwin version of host.
42 : unsigned DarwinVersion[3];
43 :
44 : /// GCC version to use on this host.
45 : unsigned GCCVersion[3];
46 :
47 : /// Cache of tool chains we have created.
48 : mutable llvm::DenseMap<unsigned, ToolChain*> ToolChains;
49 :
50 : public:
51 : DarwinHostInfo(const Driver &D, const llvm::Triple &Triple);
52 : ~DarwinHostInfo();
53 :
54 : virtual bool useDriverDriver() const;
55 :
56 44: virtual types::ID lookupTypeForExtension(const char *Ext) const {
57 44: types::ID Ty = types::lookupTypeForExtension(Ext);
58 :
59 : // Darwin always preprocesses assembly files (unless -x is used
60 : // explicitly).
1: branch 0 taken
43: branch 1 taken
61 44: if (Ty == types::TY_PP_Asm)
62 1: return types::TY_Asm;
63 :
64 43: return Ty;
65 : }
66 :
67 : virtual ToolChain *CreateToolChain(const ArgList &Args,
68 : const char *ArchName) const;
69 : };
70 :
71 60: DarwinHostInfo::DarwinHostInfo(const Driver &D, const llvm::Triple& Triple)
72 60: : HostInfo(D, Triple) {
73 :
60: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
74 60: assert(Triple.getArch() != llvm::Triple::UnknownArch && "Invalid arch!");
75 : assert(memcmp(&getOSName()[0], "darwin", 6) == 0 &&
60: branch 3 taken
0: branch 4 not taken
60: branch 5 taken
0: branch 6 not taken
0: branch 12 not taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 15 not taken
76 120: "Unknown Darwin platform.");
77 : bool HadExtra;
0: branch 4 not taken
60: branch 5 taken
0: branch 10 not taken
0: branch 11 not taken
78 60: if (!Driver::GetReleaseVersion(&getOSName()[6],
79 : DarwinVersion[0], DarwinVersion[1],
80 : DarwinVersion[2], HadExtra))
81 0: D.Diag(clang::diag::err_drv_invalid_darwin_version) << getOSName();
82 :
83 : // We can only call 4.2.1 for now.
84 60: GCCVersion[0] = 4;
85 60: GCCVersion[1] = 2;
86 60: GCCVersion[2] = 1;
87 60: }
88 :
89 60: DarwinHostInfo::~DarwinHostInfo() {
62: branch 3 taken
60: branch 4 taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 13 not taken
0: branch 14 not taken
90 122: for (llvm::DenseMap<unsigned, ToolChain*>::iterator
91 60: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
62: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
92 62: delete it->second;
60: branch 2 taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
93 60: }
94 :
95 60: bool DarwinHostInfo::useDriverDriver() const {
96 60: return true;
97 : }
98 :
99 : ToolChain *DarwinHostInfo::CreateToolChain(const ArgList &Args,
100 77: const char *ArchName) const {
101 : llvm::Triple::ArchType Arch;
102 :
60: branch 0 taken
17: branch 1 taken
103 77: if (!ArchName) {
104 : // If we aren't looking for a specific arch, infer the default architecture
105 : // based on -arch and -m32/-m64 command line options.
19: branch 2 taken
41: branch 3 taken
106 60: if (Arg *A = Args.getLastArg(options::OPT_arch)) {
107 : // The gcc driver behavior with multiple -arch flags wasn't consistent for
108 : // things which rely on a default architecture. We just use the last -arch
109 : // to find the default tool chain (assuming it is valid).
110 19: Arch = llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
111 :
112 : // If it was invalid just use the host, we will reject this command line
113 : // later.
0: branch 0 not taken
19: branch 1 taken
114 19: if (Arch == llvm::Triple::UnknownArch)
115 0: Arch = getTriple().getArch();
116 : } else {
117 : // Otherwise default to the arch of the host.
118 41: Arch = getTriple().getArch();
119 : }
120 :
121 : // Honor -m32 and -m64 when finding the default tool chain.
122 : //
123 : // FIXME: Should this information be in llvm::Triple?
8: branch 3 taken
52: branch 4 taken
124 60: if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
5: branch 3 taken
3: branch 4 taken
125 8: if (A->getOption().matches(options::OPT_m32)) {
1: branch 0 taken
4: branch 1 taken
126 5: if (Arch == llvm::Triple::x86_64)
127 1: Arch = llvm::Triple::x86;
1: branch 0 taken
4: branch 1 taken
128 5: if (Arch == llvm::Triple::ppc64)
129 1: Arch = llvm::Triple::ppc;
130 : } else {
2: branch 0 taken
1: branch 1 taken
131 3: if (Arch == llvm::Triple::x86)
132 2: Arch = llvm::Triple::x86_64;
1: branch 0 taken
2: branch 1 taken
133 3: if (Arch == llvm::Triple::ppc)
134 1: Arch = llvm::Triple::ppc64;
135 : }
136 : }
137 : } else
138 17: Arch = llvm::Triple::getArchTypeForDarwinArchName(ArchName);
139 :
0: branch 0 not taken
77: branch 1 taken
140 77: assert(Arch != llvm::Triple::UnknownArch && "Unexpected arch!");
141 77: ToolChain *&TC = ToolChains[Arch];
62: branch 0 taken
15: branch 1 taken
142 77: if (!TC) {
143 62: llvm::Triple TCTriple(getTriple());
144 62: TCTriple.setArch(Arch);
145 :
146 : // If we recognized the arch, match it to the toolchains we support.
26: branch 0 taken
36: branch 1 taken
8: branch 2 taken
18: branch 3 taken
147 106: if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
148 : // We still use the legacy DarwinGCC toolchain on X86.
149 : TC = new toolchains::DarwinGCC(*this, TCTriple, DarwinVersion,
150 44: GCCVersion);
4: branch 0 taken
14: branch 1 taken
0: branch 2 not taken
4: branch 3 taken
151 32: } else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)
152 14: TC = new toolchains::DarwinClang(*this, TCTriple, DarwinVersion);
153 : else
154 4: TC = new toolchains::Darwin_Generic_GCC(*this, TCTriple);
155 : }
156 :
157 77: return TC;
158 : }
159 :
160 : // Unknown Host Info
161 :
162 : /// UnknownHostInfo - Generic host information to use for unknown hosts.
163 : class UnknownHostInfo : public HostInfo {
164 : /// Cache of tool chains we have created.
165 : mutable llvm::StringMap<ToolChain*> ToolChains;
166 :
167 : public:
168 : UnknownHostInfo(const Driver &D, const llvm::Triple& Triple);
169 : ~UnknownHostInfo();
170 :
171 : virtual bool useDriverDriver() const;
172 :
173 21: virtual types::ID lookupTypeForExtension(const char *Ext) const {
174 21: return types::lookupTypeForExtension(Ext);
175 : }
176 :
177 : virtual ToolChain *CreateToolChain(const ArgList &Args,
178 : const char *ArchName) const;
179 : };
180 :
181 33: UnknownHostInfo::UnknownHostInfo(const Driver &D, const llvm::Triple& Triple)
182 33: : HostInfo(D, Triple) {
183 33: }
184 :
185 33: UnknownHostInfo::~UnknownHostInfo() {
33: branch 2 taken
33: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 10 not taken
0: branch 11 not taken
186 66: for (llvm::StringMap<ToolChain*>::iterator
187 33: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
33: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
188 33: delete it->second;
33: branch 2 taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
189 33: }
190 :
191 33: bool UnknownHostInfo::useDriverDriver() const {
192 33: return false;
193 : }
194 :
195 : ToolChain *UnknownHostInfo::CreateToolChain(const ArgList &Args,
196 33: const char *ArchName) const {
197 : assert(!ArchName &&
0: branch 0 not taken
33: branch 1 taken
198 33: "Unexpected arch name on platform without driver driver support.");
199 :
200 : // Automatically handle some instances of -m32/-m64 we know about.
201 33: std::string Arch = getArchName();
202 33: ArchName = Arch.c_str();
3: branch 3 taken
30: branch 4 taken
203 33: if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
1: branch 1 taken
2: branch 2 taken
1: branch 4 taken
0: branch 5 not taken
3: branch 6 taken
0: branch 7 not taken
204 3: if (Triple.getArch() == llvm::Triple::x86 ||
205 : Triple.getArch() == llvm::Triple::x86_64) {
206 : ArchName =
1: branch 3 taken
2: branch 4 taken
207 3: (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
0: branch 1 not taken
0: branch 2 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
208 0: } else if (Triple.getArch() == llvm::Triple::ppc ||
209 : Triple.getArch() == llvm::Triple::ppc64) {
210 : ArchName =
0: branch 3 not taken
0: branch 4 not taken
211 0: (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
212 : }
213 : }
214 :
215 33: ToolChain *&TC = ToolChains[ArchName];
33: branch 0 taken
0: branch 1 not taken
216 33: if (!TC) {
217 33: llvm::Triple TCTriple(getTriple());
218 33: TCTriple.setArchName(ArchName);
219 :
220 33: TC = new toolchains::Generic_GCC(*this, TCTriple);
221 : }
222 :
223 33: return TC;
224 : }
225 :
226 : // OpenBSD Host Info
227 :
228 : /// OpenBSDHostInfo - OpenBSD host information implementation.
229 : class OpenBSDHostInfo : public HostInfo {
230 : /// Cache of tool chains we have created.
231 : mutable llvm::StringMap<ToolChain*> ToolChains;
232 :
233 : public:
234 1: OpenBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
235 1: : HostInfo(D, Triple) {}
236 : ~OpenBSDHostInfo();
237 :
238 : virtual bool useDriverDriver() const;
239 :
240 1: virtual types::ID lookupTypeForExtension(const char *Ext) const {
241 1: return types::lookupTypeForExtension(Ext);
242 : }
243 :
244 : virtual ToolChain *CreateToolChain(const ArgList &Args,
245 : const char *ArchName) const;
246 : };
247 :
248 1: OpenBSDHostInfo::~OpenBSDHostInfo() {
1: branch 2 taken
1: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 10 not taken
0: branch 11 not taken
249 2: for (llvm::StringMap<ToolChain*>::iterator
250 1: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
1: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
251 1: delete it->second;
1: branch 2 taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
252 1: }
253 :
254 1: bool OpenBSDHostInfo::useDriverDriver() const {
255 1: return false;
256 : }
257 :
258 : ToolChain *OpenBSDHostInfo::CreateToolChain(const ArgList &Args,
259 1: const char *ArchName) const {
260 : assert(!ArchName &&
0: branch 0 not taken
1: branch 1 taken
261 1: "Unexpected arch name on platform without driver driver support.");
262 :
263 1: std::string Arch = getArchName();
264 1: ArchName = Arch.c_str();
265 :
266 1: ToolChain *&TC = ToolChains[ArchName];
1: branch 0 taken
0: branch 1 not taken
267 1: if (!TC) {
268 1: llvm::Triple TCTriple(getTriple());
269 1: TCTriple.setArchName(ArchName);
270 :
271 1: TC = new toolchains::OpenBSD(*this, TCTriple);
272 : }
273 :
274 1: return TC;
275 : }
276 :
277 : // AuroraUX Host Info
278 :
279 : /// AuroraUXHostInfo - AuroraUX host information implementation.
280 : class AuroraUXHostInfo : public HostInfo {
281 : /// Cache of tool chains we have created.
282 : mutable llvm::StringMap<ToolChain*> ToolChains;
283 :
284 : public:
285 0: AuroraUXHostInfo(const Driver &D, const llvm::Triple& Triple)
286 0: : HostInfo(D, Triple) {}
287 : ~AuroraUXHostInfo();
288 :
289 : virtual bool useDriverDriver() const;
290 :
291 0: virtual types::ID lookupTypeForExtension(const char *Ext) const {
292 0: return types::lookupTypeForExtension(Ext);
293 : }
294 :
295 : virtual ToolChain *CreateToolChain(const ArgList &Args,
296 : const char *ArchName) const;
297 : };
298 :
299 0: AuroraUXHostInfo::~AuroraUXHostInfo() {
0: branch 2 not taken
0: branch 3 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 10 not taken
0: branch 11 not taken
300 0: for (llvm::StringMap<ToolChain*>::iterator
301 0: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
302 0: delete it->second;
0: branch 2 not taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
303 0: }
304 :
305 0: bool AuroraUXHostInfo::useDriverDriver() const {
306 0: return false;
307 : }
308 :
309 : ToolChain *AuroraUXHostInfo::CreateToolChain(const ArgList &Args,
310 0: const char *ArchName) const {
311 : assert(!ArchName &&
0: branch 0 not taken
0: branch 1 not taken
312 0: "Unexpected arch name on platform without driver driver support.");
313 :
314 0: ToolChain *&TC = ToolChains[getArchName()];
315 :
0: branch 0 not taken
0: branch 1 not taken
316 0: if (!TC) {
317 0: llvm::Triple TCTriple(getTriple());
318 0: TCTriple.setArchName(getArchName());
319 :
320 0: TC = new toolchains::AuroraUX(*this, TCTriple);
321 : }
322 :
323 0: return TC;
324 : }
325 :
326 : // FreeBSD Host Info
327 :
328 : /// FreeBSDHostInfo - FreeBSD host information implementation.
329 : class FreeBSDHostInfo : public HostInfo {
330 : /// Cache of tool chains we have created.
331 : mutable llvm::StringMap<ToolChain*> ToolChains;
332 :
333 : public:
334 1: FreeBSDHostInfo(const Driver &D, const llvm::Triple& Triple)
335 1: : HostInfo(D, Triple) {}
336 : ~FreeBSDHostInfo();
337 :
338 : virtual bool useDriverDriver() const;
339 :
340 1: virtual types::ID lookupTypeForExtension(const char *Ext) const {
341 1: return types::lookupTypeForExtension(Ext);
342 : }
343 :
344 : virtual ToolChain *CreateToolChain(const ArgList &Args,
345 : const char *ArchName) const;
346 : };
347 :
348 1: FreeBSDHostInfo::~FreeBSDHostInfo() {
1: branch 2 taken
1: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 10 not taken
0: branch 11 not taken
349 2: for (llvm::StringMap<ToolChain*>::iterator
350 1: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
1: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
351 1: delete it->second;
1: branch 2 taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
352 1: }
353 :
354 1: bool FreeBSDHostInfo::useDriverDriver() const {
355 1: return false;
356 : }
357 :
358 : ToolChain *FreeBSDHostInfo::CreateToolChain(const ArgList &Args,
359 1: const char *ArchName) const {
360 1: bool Lib32 = false;
361 :
362 : assert(!ArchName &&
0: branch 0 not taken
1: branch 1 taken
363 1: "Unexpected arch name on platform without driver driver support.");
364 :
365 : // On x86_64 we need to be able to compile 32-bits binaries as well.
366 : // Compiling 64-bit binaries on i386 is not supported. We don't have a
367 : // lib64.
368 1: std::string Arch = getArchName();
369 1: ArchName = Arch.c_str();
0: branch 2 not taken
1: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
1: branch 9 taken
0: branch 11 not taken
1: branch 12 taken
370 1: if (Args.hasArg(options::OPT_m32) && getArchName() == "x86_64") {
371 0: ArchName = "i386";
372 0: Lib32 = true;
373 : }
374 :
375 1: ToolChain *&TC = ToolChains[ArchName];
1: branch 0 taken
0: branch 1 not taken
376 1: if (!TC) {
377 1: llvm::Triple TCTriple(getTriple());
378 1: TCTriple.setArchName(ArchName);
379 :
380 1: TC = new toolchains::FreeBSD(*this, TCTriple, Lib32);
381 : }
382 :
383 1: return TC;
384 : }
385 :
386 : // DragonFly Host Info
387 :
388 : /// DragonFlyHostInfo - DragonFly host information implementation.
389 : class DragonFlyHostInfo : public HostInfo {
390 : /// Cache of tool chains we have created.
391 : mutable llvm::StringMap<ToolChain*> ToolChains;
392 :
393 : public:
394 1: DragonFlyHostInfo(const Driver &D, const llvm::Triple& Triple)
395 1: : HostInfo(D, Triple) {}
396 : ~DragonFlyHostInfo();
397 :
398 : virtual bool useDriverDriver() const;
399 :
400 1: virtual types::ID lookupTypeForExtension(const char *Ext) const {
401 1: return types::lookupTypeForExtension(Ext);
402 : }
403 :
404 : virtual ToolChain *CreateToolChain(const ArgList &Args,
405 : const char *ArchName) const;
406 : };
407 :
408 1: DragonFlyHostInfo::~DragonFlyHostInfo() {
1: branch 2 taken
1: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 10 not taken
0: branch 11 not taken
409 2: for (llvm::StringMap<ToolChain*>::iterator
410 1: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
1: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
411 1: delete it->second;
1: branch 2 taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
412 1: }
413 :
414 1: bool DragonFlyHostInfo::useDriverDriver() const {
415 1: return false;
416 : }
417 :
418 : ToolChain *DragonFlyHostInfo::CreateToolChain(const ArgList &Args,
419 1: const char *ArchName) const {
420 : assert(!ArchName &&
0: branch 0 not taken
1: branch 1 taken
421 1: "Unexpected arch name on platform without driver driver support.");
422 :
423 1: ToolChain *&TC = ToolChains[getArchName()];
424 :
1: branch 0 taken
0: branch 1 not taken
425 1: if (!TC) {
426 1: llvm::Triple TCTriple(getTriple());
427 1: TCTriple.setArchName(getArchName());
428 :
429 1: TC = new toolchains::DragonFly(*this, TCTriple);
430 : }
431 :
432 1: return TC;
433 : }
434 :
435 : // Linux Host Info
436 :
437 : /// LinuxHostInfo - Linux host information implementation.
438 : class LinuxHostInfo : public HostInfo {
439 : /// Cache of tool chains we have created.
440 : mutable llvm::StringMap<ToolChain*> ToolChains;
441 :
442 : public:
443 152: LinuxHostInfo(const Driver &D, const llvm::Triple& Triple)
444 152: : HostInfo(D, Triple) {}
445 : ~LinuxHostInfo();
446 :
447 : virtual bool useDriverDriver() const;
448 :
449 131: virtual types::ID lookupTypeForExtension(const char *Ext) const {
450 131: return types::lookupTypeForExtension(Ext);
451 : }
452 :
453 : virtual ToolChain *CreateToolChain(const ArgList &Args,
454 : const char *ArchName) const;
455 : };
456 :
457 152: LinuxHostInfo::~LinuxHostInfo() {
152: branch 2 taken
152: branch 3 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 10 not taken
0: branch 11 not taken
458 304: for (llvm::StringMap<ToolChain*>::iterator
459 152: it = ToolChains.begin(), ie = ToolChains.end(); it != ie; ++it)
152: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
460 152: delete it->second;
152: branch 2 taken
0: branch 3 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 12 not taken
0: branch 13 not taken
461 152: }
462 :
463 144: bool LinuxHostInfo::useDriverDriver() const {
464 144: return false;
465 : }
466 :
467 : ToolChain *LinuxHostInfo::CreateToolChain(const ArgList &Args,
468 152: const char *ArchName) const {
469 :
470 : assert(!ArchName &&
0: branch 0 not taken
152: branch 1 taken
471 152: "Unexpected arch name on platform without driver driver support.");
472 :
473 : // Automatically handle some instances of -m32/-m64 we know about.
474 152: std::string Arch = getArchName();
475 152: ArchName = Arch.c_str();
2: branch 3 taken
150: branch 4 taken
476 152: if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
0: branch 1 not taken
2: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
2: branch 6 taken
0: branch 7 not taken
477 2: if (Triple.getArch() == llvm::Triple::x86 ||
478 : Triple.getArch() == llvm::Triple::x86_64) {
479 : ArchName =
1: branch 3 taken
1: branch 4 taken
480 2: (A->getOption().matches(options::OPT_m32)) ? "i386" : "x86_64";
0: branch 1 not taken
0: branch 2 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
481 0: } else if (Triple.getArch() == llvm::Triple::ppc ||
482 : Triple.getArch() == llvm::Triple::ppc64) {
483 : ArchName =
0: branch 3 not taken
0: branch 4 not taken
484 0: (A->getOption().matches(options::OPT_m32)) ? "powerpc" : "powerpc64";
485 : }
486 : }
487 :
488 152: ToolChain *&TC = ToolChains[ArchName];
489 :
152: branch 0 taken
0: branch 1 not taken
490 152: if (!TC) {
491 152: llvm::Triple TCTriple(getTriple());
492 152: TCTriple.setArchName(ArchName);
493 :
494 152: TC = new toolchains::Linux(*this, TCTriple);
495 : }
496 :
497 152: return TC;
498 : }
499 :
500 : }
501 :
502 : const HostInfo *
503 : clang::driver::createAuroraUXHostInfo(const Driver &D,
504 0: const llvm::Triple& Triple){
505 0: return new AuroraUXHostInfo(D, Triple);
506 : }
507 :
508 : const HostInfo *
509 : clang::driver::createDarwinHostInfo(const Driver &D,
510 60: const llvm::Triple& Triple){
511 60: return new DarwinHostInfo(D, Triple);
512 : }
513 :
514 : const HostInfo *
515 : clang::driver::createOpenBSDHostInfo(const Driver &D,
516 1: const llvm::Triple& Triple) {
517 1: return new OpenBSDHostInfo(D, Triple);
518 : }
519 :
520 : const HostInfo *
521 : clang::driver::createFreeBSDHostInfo(const Driver &D,
522 1: const llvm::Triple& Triple) {
523 1: return new FreeBSDHostInfo(D, Triple);
524 : }
525 :
526 : const HostInfo *
527 : clang::driver::createDragonFlyHostInfo(const Driver &D,
528 1: const llvm::Triple& Triple) {
529 1: return new DragonFlyHostInfo(D, Triple);
530 : }
531 :
532 : const HostInfo *
533 : clang::driver::createLinuxHostInfo(const Driver &D,
534 152: const llvm::Triple& Triple) {
535 152: return new LinuxHostInfo(D, Triple);
536 : }
537 :
538 : const HostInfo *
539 : clang::driver::createUnknownHostInfo(const Driver &D,
540 33: const llvm::Triple& Triple) {
541 33: return new UnknownHostInfo(D, Triple);
542 : }
Generated: 2010-02-10 01:31 by zcov