1 //===--- ToolChains.cpp - ToolChain Implementations ---------------------*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "ToolChains.h"
12 #include "clang/Driver/Arg.h"
13 #include "clang/Driver/ArgList.h"
14 #include "clang/Driver/Compilation.h"
15 #include "clang/Driver/Driver.h"
16 #include "clang/Driver/DriverDiagnostic.h"
17 #include "clang/Driver/HostInfo.h"
18 #include "clang/Driver/OptTable.h"
19 #include "clang/Driver/Option.h"
20 #include "clang/Driver/Options.h"
21 #include "clang/Basic/Version.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/MemoryBuffer.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Support/Path.h"
30 #include <cstdlib> // ::getenv
32 using namespace clang::driver
;
33 using namespace clang::driver::toolchains
;
35 /// Darwin - Darwin tool chain for i386 and x86_64.
37 Darwin::Darwin(const HostInfo
&Host
, const llvm::Triple
& Triple
)
38 : ToolChain(Host
, Triple
), TargetInitialized(false)
40 // Compute the initial Darwin version based on the host.
42 std::string OSName
= Triple
.getOSName();
43 if (!Driver::GetReleaseVersion(&OSName
[6],
44 DarwinVersion
[0], DarwinVersion
[1],
45 DarwinVersion
[2], HadExtra
))
46 getDriver().Diag(clang::diag::err_drv_invalid_darwin_version
) << OSName
;
48 llvm::raw_string_ostream(MacosxVersionMin
)
49 << "10." << std::max(0, (int)DarwinVersion
[0] - 4) << '.'
53 types::ID
Darwin::LookupTypeForExtension(const char *Ext
) const {
54 types::ID Ty
= types::lookupTypeForExtension(Ext
);
56 // Darwin always preprocesses assembly files (unless -x is used explicitly).
57 if (Ty
== types::TY_PP_Asm
)
63 bool Darwin::HasNativeLLVMSupport() const {
67 // FIXME: Can we tablegen this?
68 static const char *GetArmArchForMArch(llvm::StringRef Value
) {
69 if (Value
== "armv6k")
72 if (Value
== "armv5tej")
75 if (Value
== "xscale")
78 if (Value
== "armv4t")
81 if (Value
== "armv7" || Value
== "armv7-a" || Value
== "armv7-r" ||
82 Value
== "armv7-m" || Value
== "armv7a" || Value
== "armv7r" ||
89 // FIXME: Can we tablegen this?
90 static const char *GetArmArchForMCpu(llvm::StringRef Value
) {
91 if (Value
== "arm10tdmi" || Value
== "arm1020t" || Value
== "arm9e" ||
92 Value
== "arm946e-s" || Value
== "arm966e-s" ||
93 Value
== "arm968e-s" || Value
== "arm10e" ||
94 Value
== "arm1020e" || Value
== "arm1022e" || Value
== "arm926ej-s" ||
95 Value
== "arm1026ej-s")
98 if (Value
== "xscale")
101 if (Value
== "arm1136j-s" || Value
== "arm1136jf-s" ||
102 Value
== "arm1176jz-s" || Value
== "arm1176jzf-s")
105 if (Value
== "cortex-a8" || Value
== "cortex-r4" || Value
== "cortex-m3")
111 llvm::StringRef
Darwin::getDarwinArchName(const ArgList
&Args
) const {
112 switch (getTriple().getArch()) {
114 return getArchName();
116 case llvm::Triple::arm
: {
117 if (const Arg
*A
= Args
.getLastArg(options::OPT_march_EQ
))
118 if (const char *Arch
= GetArmArchForMArch(A
->getValue(Args
)))
121 if (const Arg
*A
= Args
.getLastArg(options::OPT_mcpu_EQ
))
122 if (const char *Arch
= GetArmArchForMCpu(A
->getValue(Args
)))
130 DarwinGCC::DarwinGCC(const HostInfo
&Host
, const llvm::Triple
& Triple
)
131 : Darwin(Host
, Triple
)
133 // We can only work with 4.2.1 currently.
138 // Set up the tool chain paths to match gcc.
139 ToolChainDir
= "i686-apple-darwin";
140 ToolChainDir
+= llvm::utostr(DarwinVersion
[0]);
142 ToolChainDir
+= llvm::utostr(GCCVersion
[0]);
144 ToolChainDir
+= llvm::utostr(GCCVersion
[1]);
146 ToolChainDir
+= llvm::utostr(GCCVersion
[2]);
148 // Try the next major version if that tool chain dir is invalid.
149 std::string Tmp
= "/usr/lib/gcc/" + ToolChainDir
;
150 if (!llvm::sys::Path(Tmp
).exists()) {
151 std::string Next
= "i686-apple-darwin";
152 Next
+= llvm::utostr(DarwinVersion
[0] + 1);
154 Next
+= llvm::utostr(GCCVersion
[0]);
156 Next
+= llvm::utostr(GCCVersion
[1]);
158 Next
+= llvm::utostr(GCCVersion
[2]);
160 // Use that if it exists, otherwise hope the user isn't linking.
162 // FIXME: Drop dependency on gcc's tool chain.
163 Tmp
= "/usr/lib/gcc/" + Next
;
164 if (llvm::sys::Path(Tmp
).exists())
169 if (getArchName() == "x86_64") {
170 Path
= getDriver().Dir
;
171 Path
+= "/../lib/gcc/";
172 Path
+= ToolChainDir
;
174 getFilePaths().push_back(Path
);
176 Path
= "/usr/lib/gcc/";
177 Path
+= ToolChainDir
;
179 getFilePaths().push_back(Path
);
182 Path
= getDriver().Dir
;
183 Path
+= "/../lib/gcc/";
184 Path
+= ToolChainDir
;
185 getFilePaths().push_back(Path
);
187 Path
= "/usr/lib/gcc/";
188 Path
+= ToolChainDir
;
189 getFilePaths().push_back(Path
);
191 Path
= getDriver().Dir
;
192 Path
+= "/../libexec/gcc/";
193 Path
+= ToolChainDir
;
194 getProgramPaths().push_back(Path
);
196 Path
= "/usr/libexec/gcc/";
197 Path
+= ToolChainDir
;
198 getProgramPaths().push_back(Path
);
200 getProgramPaths().push_back(getDriver().getInstalledDir());
201 if (getDriver().getInstalledDir() != getDriver().Dir
)
202 getProgramPaths().push_back(getDriver().Dir
);
206 // Free tool implementations.
207 for (llvm::DenseMap
<unsigned, Tool
*>::iterator
208 it
= Tools
.begin(), ie
= Tools
.end(); it
!= ie
; ++it
)
212 std::string
Darwin::ComputeEffectiveClangTriple(const ArgList
&Args
) const {
213 llvm::Triple
Triple(ComputeLLVMTriple(Args
));
215 // If the target isn't initialized (e.g., an unknown Darwin platform, return
216 // the default triple).
217 if (!isTargetInitialized())
218 return Triple
.getTriple();
221 getTargetVersion(Version
);
223 // Mangle the target version into the OS triple component. For historical
224 // reasons that make little sense, the version passed here is the "darwin"
225 // version, which drops the 10 and offsets by 4. See inverse code when
226 // setting the OS version preprocessor define.
227 if (!isTargetIPhoneOS()) {
228 Version
[0] = Version
[1] + 4;
229 Version
[1] = Version
[2];
232 // Use the environment to communicate that we are targetting iPhoneOS.
233 Triple
.setEnvironmentName("iphoneos");
236 llvm::SmallString
<16> Str
;
237 llvm::raw_svector_ostream(Str
) << "darwin" << Version
[0]
238 << "." << Version
[1] << "." << Version
[2];
239 Triple
.setOSName(Str
.str());
241 return Triple
.getTriple();
244 Tool
&Darwin::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
245 Action::ActionClass Key
;
246 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
247 Key
= Action::AnalyzeJobClass
;
251 // FIXME: This doesn't belong here, but ideally we will support static soon
253 bool HasStatic
= (C
.getArgs().hasArg(options::OPT_mkernel
) ||
254 C
.getArgs().hasArg(options::OPT_static
) ||
255 C
.getArgs().hasArg(options::OPT_fapple_kext
));
256 bool IsIADefault
= IsIntegratedAssemblerDefault() && !HasStatic
;
257 bool UseIntegratedAs
= C
.getArgs().hasFlag(options::OPT_integrated_as
,
258 options::OPT_no_integrated_as
,
261 Tool
*&T
= Tools
[Key
];
264 case Action::InputClass
:
265 case Action::BindArchClass
:
266 assert(0 && "Invalid tool kind.");
267 case Action::PreprocessJobClass
:
268 T
= new tools::darwin::Preprocess(*this); break;
269 case Action::AnalyzeJobClass
:
270 T
= new tools::Clang(*this); break;
271 case Action::PrecompileJobClass
:
272 case Action::CompileJobClass
:
273 T
= new tools::darwin::Compile(*this); break;
274 case Action::AssembleJobClass
: {
276 T
= new tools::ClangAs(*this);
278 T
= new tools::darwin::Assemble(*this);
281 case Action::LinkJobClass
:
282 T
= new tools::darwin::Link(*this); break;
283 case Action::LipoJobClass
:
284 T
= new tools::darwin::Lipo(*this); break;
285 case Action::DsymutilJobClass
:
286 T
= new tools::darwin::Dsymutil(*this); break;
293 void DarwinGCC::AddLinkSearchPathArgs(const ArgList
&Args
,
294 ArgStringList
&CmdArgs
) const {
297 // FIXME: Derive these correctly.
298 if (getArchName() == "x86_64") {
299 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir
+
301 // Intentionally duplicated for (temporary) gcc bug compatibility.
302 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir
+
306 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/" + ToolChainDir
));
308 Tmp
= getDriver().Dir
+ "/../lib/gcc/" + ToolChainDir
;
309 if (llvm::sys::Path(Tmp
).exists())
310 CmdArgs
.push_back(Args
.MakeArgString("-L" + Tmp
));
311 Tmp
= getDriver().Dir
+ "/../lib/gcc";
312 if (llvm::sys::Path(Tmp
).exists())
313 CmdArgs
.push_back(Args
.MakeArgString("-L" + Tmp
));
314 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir
));
315 // Intentionally duplicated for (temporary) gcc bug compatibility.
316 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir
));
317 Tmp
= getDriver().Dir
+ "/../lib/" + ToolChainDir
;
318 if (llvm::sys::Path(Tmp
).exists())
319 CmdArgs
.push_back(Args
.MakeArgString("-L" + Tmp
));
320 Tmp
= getDriver().Dir
+ "/../lib";
321 if (llvm::sys::Path(Tmp
).exists())
322 CmdArgs
.push_back(Args
.MakeArgString("-L" + Tmp
));
323 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir
+
324 "/../../../" + ToolChainDir
));
325 CmdArgs
.push_back(Args
.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir
+
329 void DarwinGCC::AddLinkRuntimeLibArgs(const ArgList
&Args
,
330 ArgStringList
&CmdArgs
) const {
331 // Note that this routine is only used for targetting OS X.
333 // Derived from libgcc and lib specs but refactored.
334 if (Args
.hasArg(options::OPT_static
)) {
335 CmdArgs
.push_back("-lgcc_static");
337 if (Args
.hasArg(options::OPT_static_libgcc
)) {
338 CmdArgs
.push_back("-lgcc_eh");
339 } else if (Args
.hasArg(options::OPT_miphoneos_version_min_EQ
)) {
340 // Derived from darwin_iphoneos_libgcc spec.
341 if (isTargetIPhoneOS()) {
342 CmdArgs
.push_back("-lgcc_s.1");
344 CmdArgs
.push_back("-lgcc_s.10.5");
346 } else if (Args
.hasArg(options::OPT_shared_libgcc
) ||
347 Args
.hasFlag(options::OPT_fexceptions
,
348 options::OPT_fno_exceptions
) ||
349 Args
.hasArg(options::OPT_fgnu_runtime
)) {
350 // FIXME: This is probably broken on 10.3?
351 if (isMacosxVersionLT(10, 5))
352 CmdArgs
.push_back("-lgcc_s.10.4");
353 else if (isMacosxVersionLT(10, 6))
354 CmdArgs
.push_back("-lgcc_s.10.5");
356 if (isMacosxVersionLT(10, 3, 9))
358 else if (isMacosxVersionLT(10, 5))
359 CmdArgs
.push_back("-lgcc_s.10.4");
360 else if (isMacosxVersionLT(10, 6))
361 CmdArgs
.push_back("-lgcc_s.10.5");
364 if (isTargetIPhoneOS() || isMacosxVersionLT(10, 6)) {
365 CmdArgs
.push_back("-lgcc");
366 CmdArgs
.push_back("-lSystem");
368 CmdArgs
.push_back("-lSystem");
369 CmdArgs
.push_back("-lgcc");
374 DarwinClang::DarwinClang(const HostInfo
&Host
, const llvm::Triple
& Triple
)
375 : Darwin(Host
, Triple
)
377 getProgramPaths().push_back(getDriver().getInstalledDir());
378 if (getDriver().getInstalledDir() != getDriver().Dir
)
379 getProgramPaths().push_back(getDriver().Dir
);
381 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
382 getProgramPaths().push_back(getDriver().getInstalledDir());
383 if (getDriver().getInstalledDir() != getDriver().Dir
)
384 getProgramPaths().push_back(getDriver().Dir
);
386 // For fallback, we need to know how to find the GCC cc1 executables, so we
387 // also add the GCC libexec paths. This is legiy code that can be removed once
388 // fallback is no longer useful.
389 std::string ToolChainDir
= "i686-apple-darwin";
390 ToolChainDir
+= llvm::utostr(DarwinVersion
[0]);
391 ToolChainDir
+= "/4.2.1";
393 std::string Path
= getDriver().Dir
;
394 Path
+= "/../libexec/gcc/";
395 Path
+= ToolChainDir
;
396 getProgramPaths().push_back(Path
);
398 Path
= "/usr/libexec/gcc/";
399 Path
+= ToolChainDir
;
400 getProgramPaths().push_back(Path
);
403 void DarwinClang::AddLinkSearchPathArgs(const ArgList
&Args
,
404 ArgStringList
&CmdArgs
) const {
405 // The Clang toolchain uses explicit paths for internal libraries.
407 // Unfortunately, we still might depend on a few of the libraries that are
408 // only available in the gcc library directory (in particular
409 // libstdc++.dylib). For now, hardcode the path to the known install location.
410 llvm::sys::Path
P(getDriver().Dir
);
411 P
.eraseComponent(); // .../usr/bin -> ../usr
412 P
.appendComponent("lib");
413 P
.appendComponent("gcc");
414 switch (getTriple().getArch()) {
416 assert(0 && "Invalid Darwin arch!");
417 case llvm::Triple::x86
:
418 case llvm::Triple::x86_64
:
419 P
.appendComponent("i686-apple-darwin10");
421 case llvm::Triple::arm
:
422 case llvm::Triple::thumb
:
423 P
.appendComponent("arm-apple-darwin10");
425 case llvm::Triple::ppc
:
426 case llvm::Triple::ppc64
:
427 P
.appendComponent("powerpc-apple-darwin10");
430 P
.appendComponent("4.2.1");
432 // Determine the arch specific GCC subdirectory.
433 const char *ArchSpecificDir
= 0;
434 switch (getTriple().getArch()) {
437 case llvm::Triple::arm
:
438 case llvm::Triple::thumb
: {
439 std::string Triple
= ComputeLLVMTriple(Args
);
440 llvm::StringRef TripleStr
= Triple
;
441 if (TripleStr
.startswith("armv5") || TripleStr
.startswith("thumbv5"))
442 ArchSpecificDir
= "v5";
443 else if (TripleStr
.startswith("armv6") || TripleStr
.startswith("thumbv6"))
444 ArchSpecificDir
= "v6";
445 else if (TripleStr
.startswith("armv7") || TripleStr
.startswith("thumbv7"))
446 ArchSpecificDir
= "v7";
449 case llvm::Triple::ppc64
:
450 ArchSpecificDir
= "ppc64";
452 case llvm::Triple::x86_64
:
453 ArchSpecificDir
= "x86_64";
457 if (ArchSpecificDir
) {
458 P
.appendComponent(ArchSpecificDir
);
460 CmdArgs
.push_back(Args
.MakeArgString("-L" + P
.str()));
465 CmdArgs
.push_back(Args
.MakeArgString("-L" + P
.str()));
468 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList
&Args
,
469 ArgStringList
&CmdArgs
) const {
470 // Darwin doesn't support real static executables, don't link any runtime
471 // libraries with -static.
472 if (Args
.hasArg(options::OPT_static
))
475 // Reject -static-libgcc for now, we can deal with this when and if someone
476 // cares. This is useful in situations where someone wants to statically link
477 // something like libstdc++, and needs its runtime support routines.
478 if (const Arg
*A
= Args
.getLastArg(options::OPT_static_libgcc
)) {
479 getDriver().Diag(clang::diag::err_drv_unsupported_opt
)
480 << A
->getAsString(Args
);
484 // Otherwise link libSystem, then the dynamic runtime library, and finally any
485 // target specific static runtime library.
486 CmdArgs
.push_back("-lSystem");
488 // Select the dynamic runtime library and the target specific static library.
489 const char *DarwinStaticLib
= 0;
490 if (isTargetIPhoneOS()) {
491 CmdArgs
.push_back("-lgcc_s.1");
493 // We may need some static functions for armv6/thumb which are required to
494 // be in the same linkage unit as their caller.
495 if (getDarwinArchName(Args
) == "armv6")
496 DarwinStaticLib
= "libclang_rt.armv6.a";
498 // The dynamic runtime library was merged with libSystem for 10.6 and
499 // beyond; only 10.4 and 10.5 need an additional runtime library.
500 if (isMacosxVersionLT(10, 5))
501 CmdArgs
.push_back("-lgcc_s.10.4");
502 else if (isMacosxVersionLT(10, 6))
503 CmdArgs
.push_back("-lgcc_s.10.5");
505 // For OS X, we thought we would only need a static runtime library when
506 // targetting 10.4, to provide versions of the static functions which were
507 // omitted from 10.4.dylib.
509 // Unfortunately, that turned out to not be true, because Darwin system
510 // headers can still use eprintf on i386, and it is not exported from
511 // libSystem. Therefore, we still must provide a runtime library just for
512 // the tiny tiny handful of projects that *might* use that symbol.
513 if (isMacosxVersionLT(10, 5)) {
514 DarwinStaticLib
= "libclang_rt.10.4.a";
516 if (getTriple().getArch() == llvm::Triple::x86
)
517 DarwinStaticLib
= "libclang_rt.eprintf.a";
521 /// Add the target specific static library, if needed.
522 if (DarwinStaticLib
) {
523 llvm::sys::Path
P(getDriver().ResourceDir
);
524 P
.appendComponent("lib");
525 P
.appendComponent("darwin");
526 P
.appendComponent(DarwinStaticLib
);
528 // For now, allow missing resource libraries to support developers who may
529 // not have compiler-rt checked out or integrated into their build.
531 CmdArgs
.push_back(Args
.MakeArgString(P
.str()));
535 void Darwin::AddDeploymentTarget(DerivedArgList
&Args
) const {
536 const OptTable
&Opts
= getDriver().getOpts();
538 Arg
*OSXVersion
= Args
.getLastArg(options::OPT_mmacosx_version_min_EQ
);
539 Arg
*iPhoneVersion
= Args
.getLastArg(options::OPT_miphoneos_version_min_EQ
);
540 if (OSXVersion
&& iPhoneVersion
) {
541 getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with
)
542 << OSXVersion
->getAsString(Args
)
543 << iPhoneVersion
->getAsString(Args
);
545 } else if (!OSXVersion
&& !iPhoneVersion
) {
546 // If neither OS X nor iPhoneOS targets were specified, check for
547 // environment defines.
548 const char *OSXTarget
= ::getenv("MACOSX_DEPLOYMENT_TARGET");
549 const char *iPhoneOSTarget
= ::getenv("IPHONEOS_DEPLOYMENT_TARGET");
551 // Ignore empty strings.
552 if (OSXTarget
&& OSXTarget
[0] == '\0')
554 if (iPhoneOSTarget
&& iPhoneOSTarget
[0] == '\0')
557 // Diagnose conflicting deployment targets, and choose default platform
558 // based on the tool chain.
560 // FIXME: Don't hardcode default here.
561 if (OSXTarget
&& iPhoneOSTarget
) {
562 // FIXME: We should see if we can get away with warning or erroring on
563 // this. Perhaps put under -pedantic?
564 if (getTriple().getArch() == llvm::Triple::arm
||
565 getTriple().getArch() == llvm::Triple::thumb
)
572 const Option
*O
= Opts
.getOption(options::OPT_mmacosx_version_min_EQ
);
573 OSXVersion
= Args
.MakeJoinedArg(0, O
, OSXTarget
);
574 Args
.append(OSXVersion
);
575 } else if (iPhoneOSTarget
) {
576 const Option
*O
= Opts
.getOption(options::OPT_miphoneos_version_min_EQ
);
577 iPhoneVersion
= Args
.MakeJoinedArg(0, O
, iPhoneOSTarget
);
578 Args
.append(iPhoneVersion
);
580 // Otherwise, assume we are targeting OS X.
581 const Option
*O
= Opts
.getOption(options::OPT_mmacosx_version_min_EQ
);
582 OSXVersion
= Args
.MakeJoinedArg(0, O
, MacosxVersionMin
);
583 Args
.append(OSXVersion
);
587 // Set the tool chain target information.
588 unsigned Major
, Minor
, Micro
;
591 assert(!iPhoneVersion
&& "Unknown target platform!");
592 if (!Driver::GetReleaseVersion(OSXVersion
->getValue(Args
), Major
, Minor
,
593 Micro
, HadExtra
) || HadExtra
||
594 Major
!= 10 || Minor
>= 10 || Micro
>= 10)
595 getDriver().Diag(clang::diag::err_drv_invalid_version_number
)
596 << OSXVersion
->getAsString(Args
);
598 assert(iPhoneVersion
&& "Unknown target platform!");
599 if (!Driver::GetReleaseVersion(iPhoneVersion
->getValue(Args
), Major
, Minor
,
600 Micro
, HadExtra
) || HadExtra
||
601 Major
>= 10 || Minor
>= 100 || Micro
>= 100)
602 getDriver().Diag(clang::diag::err_drv_invalid_version_number
)
603 << iPhoneVersion
->getAsString(Args
);
605 setTarget(iPhoneVersion
, Major
, Minor
, Micro
);
608 void DarwinClang::AddCXXStdlibLibArgs(const ArgList
&Args
,
609 ArgStringList
&CmdArgs
) const {
610 CXXStdlibType Type
= GetCXXStdlibType(Args
);
613 case ToolChain::CST_Libcxx
:
614 CmdArgs
.push_back("-lc++");
617 case ToolChain::CST_Libstdcxx
: {
618 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
619 // it was previously found in the gcc lib dir. However, for all the Darwin
620 // platforms we care about it was -lstdc++.6, so we search for that
621 // explicitly if we can't see an obvious -lstdc++ candidate.
623 // Check in the sysroot first.
624 if (const Arg
*A
= Args
.getLastArg(options::OPT_isysroot
)) {
625 llvm::sys::Path
P(A
->getValue(Args
));
626 P
.appendComponent("usr");
627 P
.appendComponent("lib");
628 P
.appendComponent("libstdc++.dylib");
632 P
.appendComponent("libstdc++.6.dylib");
634 CmdArgs
.push_back(Args
.MakeArgString(P
.str()));
640 // Otherwise, look in the root.
641 if (!llvm::sys::Path("/usr/lib/libstdc++.dylib").exists() &&
642 llvm::sys::Path("/usr/lib/libstdc++.6.dylib").exists()) {
643 CmdArgs
.push_back("/usr/lib/libstdc++.6.dylib");
647 // Otherwise, let the linker search.
648 CmdArgs
.push_back("-lstdc++");
654 void DarwinClang::AddCCKextLibArgs(const ArgList
&Args
,
655 ArgStringList
&CmdArgs
) const {
657 // For Darwin platforms, use the compiler-rt-based support library
658 // instead of the gcc-provided one (which is also incidentally
659 // only present in the gcc lib dir, which makes it hard to find).
661 llvm::sys::Path
P(getDriver().ResourceDir
);
662 P
.appendComponent("lib");
663 P
.appendComponent("darwin");
664 P
.appendComponent("libclang_rt.cc_kext.a");
666 // For now, allow missing resource libraries to support developers who may
667 // not have compiler-rt checked out or integrated into their build.
669 CmdArgs
.push_back(Args
.MakeArgString(P
.str()));
672 DerivedArgList
*Darwin::TranslateArgs(const DerivedArgList
&Args
,
673 const char *BoundArch
) const {
674 DerivedArgList
*DAL
= new DerivedArgList(Args
.getBaseArgs());
675 const OptTable
&Opts
= getDriver().getOpts();
677 // FIXME: We really want to get out of the tool chain level argument
678 // translation business, as it makes the driver functionality much
679 // more opaque. For now, we follow gcc closely solely for the
680 // purpose of easily achieving feature parity & testability. Once we
681 // have something that works, we should reevaluate each translation
682 // and try to push it down into tool specific logic.
684 for (ArgList::const_iterator it
= Args
.begin(),
685 ie
= Args
.end(); it
!= ie
; ++it
) {
688 if (A
->getOption().matches(options::OPT_Xarch__
)) {
689 // FIXME: Canonicalize name.
690 if (getArchName() != A
->getValue(Args
, 0))
693 unsigned Index
= Args
.getBaseArgs().MakeIndex(A
->getValue(Args
, 1));
694 unsigned Prev
= Index
;
695 Arg
*XarchArg
= Opts
.ParseOneArg(Args
, Index
);
697 // If the argument parsing failed or more than one argument was
698 // consumed, the -Xarch_ argument's parameter tried to consume
699 // extra arguments. Emit an error and ignore.
701 // We also want to disallow any options which would alter the
702 // driver behavior; that isn't going to work in our model. We
703 // use isDriverOption() as an approximation, although things
704 // like -O4 are going to slip through.
705 if (!XarchArg
|| Index
> Prev
+ 1 ||
706 XarchArg
->getOption().isDriverOption()) {
707 getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument
)
708 << A
->getAsString(Args
);
712 XarchArg
->setBaseArg(A
);
715 DAL
->AddSynthesizedArg(A
);
718 // Sob. These is strictly gcc compatible for the time being. Apple
719 // gcc translates options twice, which means that self-expanding
720 // options add duplicates.
721 switch ((options::ID
) A
->getOption().getID()) {
726 case options::OPT_mkernel
:
727 case options::OPT_fapple_kext
:
729 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_static
));
730 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_static
));
733 case options::OPT_dependency_file
:
734 DAL
->AddSeparateArg(A
, Opts
.getOption(options::OPT_MF
),
738 case options::OPT_gfull
:
739 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_g_Flag
));
741 Opts
.getOption(options::OPT_fno_eliminate_unused_debug_symbols
));
744 case options::OPT_gused
:
745 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_g_Flag
));
747 Opts
.getOption(options::OPT_feliminate_unused_debug_symbols
));
750 case options::OPT_fterminated_vtables
:
751 case options::OPT_findirect_virtual_calls
:
752 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_fapple_kext
));
753 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_static
));
756 case options::OPT_shared
:
757 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_dynamiclib
));
760 case options::OPT_fconstant_cfstrings
:
761 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_mconstant_cfstrings
));
764 case options::OPT_fno_constant_cfstrings
:
765 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_mno_constant_cfstrings
));
768 case options::OPT_Wnonportable_cfstrings
:
770 Opts
.getOption(options::OPT_mwarn_nonportable_cfstrings
));
773 case options::OPT_Wno_nonportable_cfstrings
:
775 Opts
.getOption(options::OPT_mno_warn_nonportable_cfstrings
));
778 case options::OPT_fpascal_strings
:
779 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_mpascal_strings
));
782 case options::OPT_fno_pascal_strings
:
783 DAL
->AddFlagArg(A
, Opts
.getOption(options::OPT_mno_pascal_strings
));
788 if (getTriple().getArch() == llvm::Triple::x86
||
789 getTriple().getArch() == llvm::Triple::x86_64
)
790 if (!Args
.hasArgNoClaim(options::OPT_mtune_EQ
))
791 DAL
->AddJoinedArg(0, Opts
.getOption(options::OPT_mtune_EQ
), "core2");
793 // Add the arch options based on the particular spelling of -arch, to match
794 // how the driver driver works.
796 llvm::StringRef Name
= BoundArch
;
797 const Option
*MCpu
= Opts
.getOption(options::OPT_mcpu_EQ
);
798 const Option
*MArch
= Opts
.getOption(options::OPT_march_EQ
);
800 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
801 // which defines the list of which architectures we accept.
804 else if (Name
== "ppc601")
805 DAL
->AddJoinedArg(0, MCpu
, "601");
806 else if (Name
== "ppc603")
807 DAL
->AddJoinedArg(0, MCpu
, "603");
808 else if (Name
== "ppc604")
809 DAL
->AddJoinedArg(0, MCpu
, "604");
810 else if (Name
== "ppc604e")
811 DAL
->AddJoinedArg(0, MCpu
, "604e");
812 else if (Name
== "ppc750")
813 DAL
->AddJoinedArg(0, MCpu
, "750");
814 else if (Name
== "ppc7400")
815 DAL
->AddJoinedArg(0, MCpu
, "7400");
816 else if (Name
== "ppc7450")
817 DAL
->AddJoinedArg(0, MCpu
, "7450");
818 else if (Name
== "ppc970")
819 DAL
->AddJoinedArg(0, MCpu
, "970");
821 else if (Name
== "ppc64")
822 DAL
->AddFlagArg(0, Opts
.getOption(options::OPT_m64
));
824 else if (Name
== "i386")
826 else if (Name
== "i486")
827 DAL
->AddJoinedArg(0, MArch
, "i486");
828 else if (Name
== "i586")
829 DAL
->AddJoinedArg(0, MArch
, "i586");
830 else if (Name
== "i686")
831 DAL
->AddJoinedArg(0, MArch
, "i686");
832 else if (Name
== "pentium")
833 DAL
->AddJoinedArg(0, MArch
, "pentium");
834 else if (Name
== "pentium2")
835 DAL
->AddJoinedArg(0, MArch
, "pentium2");
836 else if (Name
== "pentpro")
837 DAL
->AddJoinedArg(0, MArch
, "pentiumpro");
838 else if (Name
== "pentIIm3")
839 DAL
->AddJoinedArg(0, MArch
, "pentium2");
841 else if (Name
== "x86_64")
842 DAL
->AddFlagArg(0, Opts
.getOption(options::OPT_m64
));
844 else if (Name
== "arm")
845 DAL
->AddJoinedArg(0, MArch
, "armv4t");
846 else if (Name
== "armv4t")
847 DAL
->AddJoinedArg(0, MArch
, "armv4t");
848 else if (Name
== "armv5")
849 DAL
->AddJoinedArg(0, MArch
, "armv5tej");
850 else if (Name
== "xscale")
851 DAL
->AddJoinedArg(0, MArch
, "xscale");
852 else if (Name
== "armv6")
853 DAL
->AddJoinedArg(0, MArch
, "armv6k");
854 else if (Name
== "armv7")
855 DAL
->AddJoinedArg(0, MArch
, "armv7a");
858 llvm_unreachable("invalid Darwin arch");
861 // Add an explicit version min argument for the deployment target. We do this
862 // after argument translation because -Xarch_ arguments may add a version min
864 AddDeploymentTarget(*DAL
);
869 bool Darwin::IsUnwindTablesDefault() const {
870 // FIXME: Gross; we should probably have some separate target
871 // definition, possibly even reusing the one in clang.
872 return getArchName() == "x86_64";
875 bool Darwin::UseDwarfDebugFlags() const {
876 if (const char *S
= ::getenv("RC_DEBUG_OPTIONS"))
881 bool Darwin::UseSjLjExceptions() const {
882 // Darwin uses SjLj exceptions on ARM.
883 return (getTriple().getArch() == llvm::Triple::arm
||
884 getTriple().getArch() == llvm::Triple::thumb
);
887 const char *Darwin::GetDefaultRelocationModel() const {
891 const char *Darwin::GetForcedPicModel() const {
892 if (getArchName() == "x86_64")
897 bool Darwin::SupportsObjCGC() const {
898 // Garbage collection is supported everywhere except on iPhone OS.
899 return !isTargetIPhoneOS();
903 Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList
&Args
) const {
904 return ComputeLLVMTriple(Args
);
907 /// Generic_GCC - A tool chain using the 'gcc' command to perform
908 /// all subcommands; this relies on gcc translating the majority of
909 /// command line options.
911 Generic_GCC::Generic_GCC(const HostInfo
&Host
, const llvm::Triple
& Triple
)
912 : ToolChain(Host
, Triple
) {
913 getProgramPaths().push_back(getDriver().getInstalledDir());
914 if (getDriver().getInstalledDir() != getDriver().Dir
.c_str())
915 getProgramPaths().push_back(getDriver().Dir
);
918 Generic_GCC::~Generic_GCC() {
919 // Free tool implementations.
920 for (llvm::DenseMap
<unsigned, Tool
*>::iterator
921 it
= Tools
.begin(), ie
= Tools
.end(); it
!= ie
; ++it
)
925 Tool
&Generic_GCC::SelectTool(const Compilation
&C
,
926 const JobAction
&JA
) const {
927 Action::ActionClass Key
;
928 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
929 Key
= Action::AnalyzeJobClass
;
933 Tool
*&T
= Tools
[Key
];
936 case Action::InputClass
:
937 case Action::BindArchClass
:
938 assert(0 && "Invalid tool kind.");
939 case Action::PreprocessJobClass
:
940 T
= new tools::gcc::Preprocess(*this); break;
941 case Action::PrecompileJobClass
:
942 T
= new tools::gcc::Precompile(*this); break;
943 case Action::AnalyzeJobClass
:
944 T
= new tools::Clang(*this); break;
945 case Action::CompileJobClass
:
946 T
= new tools::gcc::Compile(*this); break;
947 case Action::AssembleJobClass
:
948 T
= new tools::gcc::Assemble(*this); break;
949 case Action::LinkJobClass
:
950 T
= new tools::gcc::Link(*this); break;
952 // This is a bit ungeneric, but the only platform using a driver
954 case Action::LipoJobClass
:
955 T
= new tools::darwin::Lipo(*this); break;
956 case Action::DsymutilJobClass
:
957 T
= new tools::darwin::Dsymutil(*this); break;
964 bool Generic_GCC::IsUnwindTablesDefault() const {
965 // FIXME: Gross; we should probably have some separate target
966 // definition, possibly even reusing the one in clang.
967 return getArchName() == "x86_64";
970 const char *Generic_GCC::GetDefaultRelocationModel() const {
974 const char *Generic_GCC::GetForcedPicModel() const {
978 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
979 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
980 /// Currently does not support anything else but compilation.
982 TCEToolChain::TCEToolChain(const HostInfo
&Host
, const llvm::Triple
& Triple
)
983 : ToolChain(Host
, Triple
) {
984 // Path mangling to find libexec
985 std::string
Path(getDriver().Dir
);
987 Path
+= "/../libexec";
988 getProgramPaths().push_back(Path
);
991 TCEToolChain::~TCEToolChain() {
992 for (llvm::DenseMap
<unsigned, Tool
*>::iterator
993 it
= Tools
.begin(), ie
= Tools
.end(); it
!= ie
; ++it
)
997 bool TCEToolChain::IsMathErrnoDefault() const {
1001 bool TCEToolChain::IsUnwindTablesDefault() const {
1005 const char *TCEToolChain::GetDefaultRelocationModel() const {
1009 const char *TCEToolChain::GetForcedPicModel() const {
1013 Tool
&TCEToolChain::SelectTool(const Compilation
&C
,
1014 const JobAction
&JA
) const {
1015 Action::ActionClass Key
;
1016 Key
= Action::AnalyzeJobClass
;
1018 Tool
*&T
= Tools
[Key
];
1021 case Action::PreprocessJobClass
:
1022 T
= new tools::gcc::Preprocess(*this); break;
1023 case Action::AnalyzeJobClass
:
1024 T
= new tools::Clang(*this); break;
1026 assert(false && "Unsupported action for TCE target.");
1032 /// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly.
1034 OpenBSD::OpenBSD(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1035 : Generic_ELF(Host
, Triple
) {
1036 getFilePaths().push_back(getDriver().Dir
+ "/../lib");
1037 getFilePaths().push_back("/usr/lib");
1040 Tool
&OpenBSD::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1041 Action::ActionClass Key
;
1042 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1043 Key
= Action::AnalyzeJobClass
;
1047 bool UseIntegratedAs
= C
.getArgs().hasFlag(options::OPT_integrated_as
,
1048 options::OPT_no_integrated_as
,
1049 IsIntegratedAssemblerDefault());
1051 Tool
*&T
= Tools
[Key
];
1054 case Action::AssembleJobClass
: {
1055 if (UseIntegratedAs
)
1056 T
= new tools::ClangAs(*this);
1058 T
= new tools::openbsd::Assemble(*this);
1061 case Action::LinkJobClass
:
1062 T
= new tools::openbsd::Link(*this); break;
1064 T
= &Generic_GCC::SelectTool(C
, JA
);
1071 /// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly.
1073 FreeBSD::FreeBSD(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1074 : Generic_ELF(Host
, Triple
) {
1076 // Determine if we are compiling 32-bit code on an x86_64 platform.
1078 if (Triple
.getArch() == llvm::Triple::x86
&&
1079 llvm::Triple(getDriver().DefaultHostTriple
).getArch() ==
1080 llvm::Triple::x86_64
)
1083 getProgramPaths().push_back(getDriver().Dir
+ "/../libexec");
1084 getProgramPaths().push_back("/usr/libexec");
1086 getFilePaths().push_back(getDriver().Dir
+ "/../lib32");
1087 getFilePaths().push_back("/usr/lib32");
1089 getFilePaths().push_back(getDriver().Dir
+ "/../lib");
1090 getFilePaths().push_back("/usr/lib");
1094 Tool
&FreeBSD::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1095 Action::ActionClass Key
;
1096 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1097 Key
= Action::AnalyzeJobClass
;
1101 bool UseIntegratedAs
= C
.getArgs().hasFlag(options::OPT_integrated_as
,
1102 options::OPT_no_integrated_as
,
1103 IsIntegratedAssemblerDefault());
1105 Tool
*&T
= Tools
[Key
];
1108 case Action::AssembleJobClass
:
1109 if (UseIntegratedAs
)
1110 T
= new tools::ClangAs(*this);
1112 T
= new tools::freebsd::Assemble(*this);
1114 case Action::LinkJobClass
:
1115 T
= new tools::freebsd::Link(*this); break;
1117 T
= &Generic_GCC::SelectTool(C
, JA
);
1124 /// Minix - Minix tool chain which can call as(1) and ld(1) directly.
1126 Minix::Minix(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1127 : Generic_GCC(Host
, Triple
) {
1128 getFilePaths().push_back(getDriver().Dir
+ "/../lib");
1129 getFilePaths().push_back("/usr/lib");
1130 getFilePaths().push_back("/usr/gnu/lib");
1131 getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
1134 Tool
&Minix::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1135 Action::ActionClass Key
;
1136 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1137 Key
= Action::AnalyzeJobClass
;
1141 Tool
*&T
= Tools
[Key
];
1144 case Action::AssembleJobClass
:
1145 T
= new tools::minix::Assemble(*this); break;
1146 case Action::LinkJobClass
:
1147 T
= new tools::minix::Link(*this); break;
1149 T
= &Generic_GCC::SelectTool(C
, JA
);
1156 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
1158 AuroraUX::AuroraUX(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1159 : Generic_GCC(Host
, Triple
) {
1161 getProgramPaths().push_back(getDriver().getInstalledDir());
1162 if (getDriver().getInstalledDir() != getDriver().Dir
.c_str())
1163 getProgramPaths().push_back(getDriver().Dir
);
1165 getFilePaths().push_back(getDriver().Dir
+ "/../lib");
1166 getFilePaths().push_back("/usr/lib");
1167 getFilePaths().push_back("/usr/sfw/lib");
1168 getFilePaths().push_back("/opt/gcc4/lib");
1169 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4");
1173 Tool
&AuroraUX::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1174 Action::ActionClass Key
;
1175 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1176 Key
= Action::AnalyzeJobClass
;
1180 Tool
*&T
= Tools
[Key
];
1183 case Action::AssembleJobClass
:
1184 T
= new tools::auroraux::Assemble(*this); break;
1185 case Action::LinkJobClass
:
1186 T
= new tools::auroraux::Link(*this); break;
1188 T
= &Generic_GCC::SelectTool(C
, JA
);
1196 /// Linux toolchain (very bare-bones at the moment).
1212 static bool IsFedora(enum LinuxDistro Distro
) {
1213 return Distro
== Fedora13
|| Distro
== Fedora14
;
1216 static bool IsOpenSuse(enum LinuxDistro Distro
) {
1217 return Distro
== OpenSuse11_3
;
1220 static bool IsDebian(enum LinuxDistro Distro
) {
1221 return Distro
== DebianLenny
|| Distro
== DebianSqueeze
;
1224 static bool IsUbuntu(enum LinuxDistro Distro
) {
1225 return Distro
== UbuntuLucid
|| Distro
== UbuntuMaverick
||
1226 Distro
== UbuntuJaunty
|| Distro
== UbuntuKarmic
;
1229 static bool IsDebianBased(enum LinuxDistro Distro
) {
1230 return IsDebian(Distro
) || IsUbuntu(Distro
);
1233 static bool HasMultilib(llvm::Triple::ArchType Arch
, enum LinuxDistro Distro
) {
1234 if (Arch
== llvm::Triple::x86_64
) {
1235 if (Distro
== Exherbo
&& !llvm::sys::Path("/usr/lib32/libc.so").exists())
1240 if (Arch
== llvm::Triple::x86
&& IsDebianBased(Distro
))
1245 static LinuxDistro
DetectLinuxDistro(llvm::Triple::ArchType Arch
) {
1246 llvm::OwningPtr
<const llvm::MemoryBuffer
>
1247 LsbRelease(llvm::MemoryBuffer::getFile("/etc/lsb-release"));
1249 llvm::StringRef Data
= LsbRelease
.get()->getBuffer();
1250 llvm::SmallVector
<llvm::StringRef
, 8> Lines
;
1251 Data
.split(Lines
, "\n");
1252 for (unsigned int i
= 0, s
= Lines
.size(); i
< s
; ++ i
) {
1253 if (Lines
[i
] == "DISTRIB_CODENAME=maverick")
1254 return UbuntuMaverick
;
1255 else if (Lines
[i
] == "DISTRIB_CODENAME=lucid")
1257 else if (Lines
[i
] == "DISTRIB_CODENAME=jaunty")
1258 return UbuntuJaunty
;
1259 else if (Lines
[i
] == "DISTRIB_CODENAME=karmic")
1260 return UbuntuKarmic
;
1262 return UnknownDistro
;
1265 llvm::OwningPtr
<const llvm::MemoryBuffer
>
1266 RHRelease(llvm::MemoryBuffer::getFile("/etc/redhat-release"));
1268 llvm::StringRef Data
= RHRelease
.get()->getBuffer();
1269 if (Data
.startswith("Fedora release 14 (Laughlin)"))
1271 else if (Data
.startswith("Fedora release 13 (Goddard)"))
1273 return UnknownDistro
;
1276 llvm::OwningPtr
<const llvm::MemoryBuffer
>
1277 DebianVersion(llvm::MemoryBuffer::getFile("/etc/debian_version"));
1278 if (DebianVersion
) {
1279 llvm::StringRef Data
= DebianVersion
.get()->getBuffer();
1282 else if (Data
.startswith("squeeze/sid"))
1283 return DebianSqueeze
;
1284 return UnknownDistro
;
1287 llvm::OwningPtr
<const llvm::MemoryBuffer
>
1288 SuseRelease(llvm::MemoryBuffer::getFile("/etc/SuSE-release"));
1290 llvm::StringRef Data
= SuseRelease
.get()->getBuffer();
1291 if (Data
.startswith("openSUSE 11.3"))
1292 return OpenSuse11_3
;
1293 return UnknownDistro
;
1296 if (llvm::sys::Path("/etc/exherbo-release").exists())
1299 return UnknownDistro
;
1302 Linux::Linux(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1303 : Generic_ELF(Host
, Triple
) {
1304 llvm::Triple::ArchType Arch
=
1305 llvm::Triple(getDriver().DefaultHostTriple
).getArch();
1307 std::string Suffix32
= "";
1308 if (Arch
== llvm::Triple::x86_64
)
1311 std::string Suffix64
= "";
1312 if (Arch
== llvm::Triple::x86
)
1315 std::string Lib32
= "lib";
1317 if ( llvm::sys::Path("/lib32").exists())
1320 std::string Lib64
= "lib";
1321 llvm::sys::Path
Lib64Path("/lib64");
1322 if (Lib64Path
.exists() && !Lib64Path
.isSymLink())
1325 std::string GccTriple
= "";
1326 if (Arch
== llvm::Triple::arm
) {
1327 if (llvm::sys::Path("/usr/lib/gcc/arm-linux-gnueabi").exists())
1328 GccTriple
= "arm-linux-gnueabi";
1329 } else if (Arch
== llvm::Triple::x86_64
) {
1330 if (llvm::sys::Path("/usr/lib/gcc/x86_64-linux-gnu").exists())
1331 GccTriple
= "x86_64-linux-gnu";
1332 else if (llvm::sys::Path("/usr/lib/gcc/x86_64-unknown-linux-gnu").exists())
1333 GccTriple
= "x86_64-unknown-linux-gnu";
1334 else if (llvm::sys::Path("/usr/lib/gcc/x86_64-pc-linux-gnu").exists())
1335 GccTriple
= "x86_64-pc-linux-gnu";
1336 else if (llvm::sys::Path("/usr/lib/gcc/x86_64-redhat-linux").exists())
1337 GccTriple
= "x86_64-redhat-linux";
1338 else if (llvm::sys::Path("/usr/lib64/gcc/x86_64-suse-linux").exists())
1339 GccTriple
= "x86_64-suse-linux";
1340 } else if (Arch
== llvm::Triple::x86
) {
1341 if (llvm::sys::Path("/usr/lib/gcc/i686-linux-gnu").exists())
1342 GccTriple
= "i686-linux-gnu";
1343 else if (llvm::sys::Path("/usr/lib/gcc/i686-pc-linux-gnu").exists())
1344 GccTriple
= "i686-pc-linux-gnu";
1345 else if (llvm::sys::Path("/usr/lib/gcc/i486-linux-gnu").exists())
1346 GccTriple
= "i486-linux-gnu";
1347 else if (llvm::sys::Path("/usr/lib/gcc/i686-redhat-linux").exists())
1348 GccTriple
= "i686-redhat-linux";
1349 else if (llvm::sys::Path("/usr/lib/gcc/i586-suse-linux").exists())
1350 GccTriple
= "i586-suse-linux";
1353 const char* GccVersions
[] = {"4.5.1", "4.5", "4.4.5", "4.4.4", "4.4.3", "4.4",
1354 "4.3.4", "4.3.3", "4.3.2"};
1355 std::string Base
= "";
1356 for (unsigned i
= 0; i
< sizeof(GccVersions
)/sizeof(char*); ++i
) {
1357 std::string Suffix
= GccTriple
+ "/" + GccVersions
[i
];
1358 std::string t1
= "/usr/lib/gcc/" + Suffix
;
1359 if (llvm::sys::Path(t1
+ "/crtbegin.o").exists()) {
1363 std::string t2
= "/usr/lib64/gcc/" + Suffix
;
1364 if (llvm::sys::Path(t2
+ "/crtbegin.o").exists()) {
1370 path_list
&Paths
= getFilePaths();
1371 bool Is32Bits
= getArch() == llvm::Triple::x86
;
1384 llvm::sys::Path
LinkerPath(Base
+ "/../../../../" + GccTriple
+ "/bin/ld");
1385 if (LinkerPath
.exists())
1386 Linker
= LinkerPath
.str();
1388 Linker
= GetProgramPath("ld");
1390 LinuxDistro Distro
= DetectLinuxDistro(Arch
);
1392 if (IsUbuntu(Distro
)) {
1393 ExtraOpts
.push_back("-z");
1394 ExtraOpts
.push_back("relro");
1397 if (Arch
== llvm::Triple::arm
)
1398 ExtraOpts
.push_back("-X");
1400 if (IsFedora(Distro
) || Distro
== UbuntuMaverick
)
1401 ExtraOpts
.push_back("--hash-style=gnu");
1403 if (IsDebian(Distro
) || Distro
== UbuntuLucid
|| Distro
== UbuntuJaunty
||
1404 Distro
== UbuntuKarmic
)
1405 ExtraOpts
.push_back("--hash-style=both");
1407 if (IsFedora(Distro
))
1408 ExtraOpts
.push_back("--no-add-needed");
1410 if (Distro
== DebianSqueeze
|| IsOpenSuse(Distro
) ||
1411 IsFedora(Distro
) || Distro
== UbuntuLucid
|| Distro
== UbuntuMaverick
||
1412 Distro
== UbuntuKarmic
)
1413 ExtraOpts
.push_back("--build-id");
1415 Paths
.push_back(Base
+ Suffix
);
1416 if (HasMultilib(Arch
, Distro
)) {
1417 if (IsOpenSuse(Distro
) && Is32Bits
)
1418 Paths
.push_back(Base
+ "/../../../../" + GccTriple
+ "/lib/../lib");
1419 Paths
.push_back(Base
+ "/../../../../" + Lib
);
1420 Paths
.push_back("/lib/../" + Lib
);
1421 Paths
.push_back("/usr/lib/../" + Lib
);
1423 if (!Suffix
.empty())
1424 Paths
.push_back(Base
);
1425 if (IsOpenSuse(Distro
))
1426 Paths
.push_back(Base
+ "/../../../../" + GccTriple
+ "/lib");
1427 Paths
.push_back(Base
+ "/../../..");
1428 if (Arch
== getArch() && IsUbuntu(Distro
))
1429 Paths
.push_back("/usr/lib/" + GccTriple
);
1432 bool Linux::HasNativeLLVMSupport() const {
1436 Tool
&Linux::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1437 Action::ActionClass Key
;
1438 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1439 Key
= Action::AnalyzeJobClass
;
1443 bool UseIntegratedAs
= C
.getArgs().hasFlag(options::OPT_integrated_as
,
1444 options::OPT_no_integrated_as
,
1445 IsIntegratedAssemblerDefault());
1447 Tool
*&T
= Tools
[Key
];
1450 case Action::AssembleJobClass
:
1451 if (UseIntegratedAs
)
1452 T
= new tools::ClangAs(*this);
1454 T
= new tools::linuxtools::Assemble(*this);
1456 case Action::LinkJobClass
:
1457 T
= new tools::linuxtools::Link(*this); break;
1459 T
= &Generic_GCC::SelectTool(C
, JA
);
1466 /// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly.
1468 DragonFly::DragonFly(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1469 : Generic_ELF(Host
, Triple
) {
1471 // Path mangling to find libexec
1472 getProgramPaths().push_back(getDriver().getInstalledDir());
1473 if (getDriver().getInstalledDir() != getDriver().Dir
.c_str())
1474 getProgramPaths().push_back(getDriver().Dir
);
1476 getFilePaths().push_back(getDriver().Dir
+ "/../lib");
1477 getFilePaths().push_back("/usr/lib");
1478 getFilePaths().push_back("/usr/lib/gcc41");
1481 Tool
&DragonFly::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1482 Action::ActionClass Key
;
1483 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1484 Key
= Action::AnalyzeJobClass
;
1488 Tool
*&T
= Tools
[Key
];
1491 case Action::AssembleJobClass
:
1492 T
= new tools::dragonfly::Assemble(*this); break;
1493 case Action::LinkJobClass
:
1494 T
= new tools::dragonfly::Link(*this); break;
1496 T
= &Generic_GCC::SelectTool(C
, JA
);
1503 Windows::Windows(const HostInfo
&Host
, const llvm::Triple
& Triple
)
1504 : ToolChain(Host
, Triple
) {
1507 Tool
&Windows::SelectTool(const Compilation
&C
, const JobAction
&JA
) const {
1508 Action::ActionClass Key
;
1509 if (getDriver().ShouldUseClangCompiler(C
, JA
, getTriple()))
1510 Key
= Action::AnalyzeJobClass
;
1514 Tool
*&T
= Tools
[Key
];
1517 case Action::InputClass
:
1518 case Action::BindArchClass
:
1519 case Action::LipoJobClass
:
1520 case Action::DsymutilJobClass
:
1521 assert(0 && "Invalid tool kind.");
1522 case Action::PreprocessJobClass
:
1523 case Action::PrecompileJobClass
:
1524 case Action::AnalyzeJobClass
:
1525 case Action::CompileJobClass
:
1526 T
= new tools::Clang(*this); break;
1527 case Action::AssembleJobClass
:
1528 T
= new tools::ClangAs(*this); break;
1529 case Action::LinkJobClass
:
1530 T
= new tools::visualstudio::Link(*this); break;
1537 bool Windows::IsIntegratedAssemblerDefault() const {
1541 bool Windows::IsUnwindTablesDefault() const {
1542 // FIXME: Gross; we should probably have some separate target
1543 // definition, possibly even reusing the one in clang.
1544 return getArchName() == "x86_64";
1547 const char *Windows::GetDefaultRelocationModel() const {
1551 const char *Windows::GetForcedPicModel() const {
1552 if (getArchName() == "x86_64")