2009-03-18 05:38:00 +08:00
|
|
|
//===--- ToolChains.h - ToolChain Implementations ---------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef CLANG_LIB_DRIVER_TOOLCHAINS_H_
|
|
|
|
#define CLANG_LIB_DRIVER_TOOLCHAINS_H_
|
|
|
|
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "Tools.h"
|
|
|
|
#include "clang/Basic/VersionTuple.h"
|
2009-03-18 06:07:31 +08:00
|
|
|
#include "clang/Driver/Action.h"
|
2009-03-18 05:38:00 +08:00
|
|
|
#include "clang/Driver/ToolChain.h"
|
2009-03-18 06:07:31 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2009-03-18 05:38:00 +08:00
|
|
|
#include "llvm/Support/Compiler.h"
|
|
|
|
|
|
|
|
namespace clang {
|
|
|
|
namespace driver {
|
2009-03-18 06:18:43 +08:00
|
|
|
namespace toolchains {
|
2009-03-18 05:38:00 +08:00
|
|
|
|
2009-09-18 16:15:13 +08:00
|
|
|
/// Generic_GCC - A tool chain using the 'gcc' command to perform
|
|
|
|
/// all subcommands; this relies on gcc translating the majority of
|
|
|
|
/// command line options.
|
2010-05-12 04:16:05 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
|
2009-03-31 05:06:03 +08:00
|
|
|
protected:
|
2011-11-07 07:39:34 +08:00
|
|
|
/// \brief Struct to store and manipulate GCC versions.
|
|
|
|
///
|
|
|
|
/// We rely on assumptions about the form and structure of GCC version
|
|
|
|
/// numbers: they consist of at most three '.'-separated components, and each
|
|
|
|
/// component is a non-negative integer except for the last component. For
|
|
|
|
/// the last component we are very flexible in order to tolerate release
|
|
|
|
/// candidates or 'x' wildcards.
|
|
|
|
///
|
|
|
|
/// Note that the ordering established among GCCVersions is based on the
|
|
|
|
/// preferred version string to use. For example we prefer versions without
|
|
|
|
/// a hard-coded patch number to those with a hard coded patch number.
|
|
|
|
///
|
|
|
|
/// Currently this doesn't provide any logic for textual suffixes to patches
|
|
|
|
/// in the way that (for example) Debian's version format does. If that ever
|
|
|
|
/// becomes necessary, it can be added.
|
|
|
|
struct GCCVersion {
|
|
|
|
/// \brief The unparsed text of the version.
|
|
|
|
std::string Text;
|
|
|
|
|
|
|
|
/// \brief The parsed major, minor, and patch numbers.
|
|
|
|
int Major, Minor, Patch;
|
|
|
|
|
|
|
|
/// \brief Any textual suffix on the patch number.
|
|
|
|
std::string PatchSuffix;
|
|
|
|
|
|
|
|
static GCCVersion Parse(StringRef VersionText);
|
|
|
|
bool operator<(const GCCVersion &RHS) const;
|
|
|
|
bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
|
|
|
|
bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
|
|
|
|
bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/// \brief This is a class to find a viable GCC installation for Clang to
|
|
|
|
/// use.
|
|
|
|
///
|
|
|
|
/// This class tries to find a GCC installation on the system, and report
|
|
|
|
/// information about it. It starts from the host information provided to the
|
|
|
|
/// Driver, and has logic for fuzzing that where appropriate.
|
|
|
|
class GCCInstallationDetector {
|
|
|
|
|
|
|
|
bool IsValid;
|
2012-01-25 03:28:29 +08:00
|
|
|
llvm::Triple GCCTriple;
|
2011-11-07 07:39:34 +08:00
|
|
|
|
|
|
|
// FIXME: These might be better as path objects.
|
2012-01-25 03:21:42 +08:00
|
|
|
std::string GCCInstallPath;
|
Make a major refactoring to how the GCC installation detection works.
The fundamental shift here is to stop making *any* assumptions about the
*host* triple. Where these assumptions you ask? Why, they were in one of
the two target triples referenced of course. This was the single biggest
place where the previously named "host triple" was actually used as
such. ;] The reason we were reasoning about the host is in order to
detect the use of '-m32' or '-m64' flags to change the target. These
flags shift the default target only slightly, which typically means
a slight deviation from the host. When using these flags, the GCC
installation is under a different triple from the one actually targeted
in the compilation, and we used the host triple to find it.
Too bad that wasn't even correct. Consider an x86 Linux host which has
a PPC64 cross-compiling GCC toolchain installed. This toolchain is also
configured for multiarch compiling and can target PPC32 with eth '-m32'
flag. When targeting 'powerpc-linux-gnu' or some other PPC32 triple, we
have to look for the PPC64 variant of the triple to find the GCC
install, and that triple is neither the host nor target.
The new logic computes the multiarch's alternate triple from the target
triple, and looks under both sides. It also looks more aggressively for
the correct subdirectory of the GCC installation, and exposes the
subdirectory in a nice programmatic way. This '/32' or '/64' suffix is
something we can reuse in many other parts of the toolchain.
An important note -- while this likely fixes a large category of
cross-compile use cases, that's not my primary goal, and I've not done
testing (or added test cases) for scenarios that may now work. If
someone else wants to try more interesting PPC cross compiles, I'd love
to have reports. But my focus is on factoring away the references to the
"host" triple. The refactoring is my goal, and so I'm mostly relying on
the existing (pretty good) test coverage we have here.
Future patches will leverage this new functionality to factor out more
and more of the toolchain's triple manipulation.
llvm-svn: 148935
2012-01-25 15:21:38 +08:00
|
|
|
std::string GCCMultiarchSuffix;
|
2012-01-25 03:21:42 +08:00
|
|
|
std::string GCCParentLibPath;
|
2011-11-07 07:39:34 +08:00
|
|
|
|
|
|
|
GCCVersion Version;
|
|
|
|
|
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
GCCInstallationDetector(const Driver &D, const llvm::Triple &TargetTriple,
|
|
|
|
const ArgList &Args);
|
2011-11-07 07:39:34 +08:00
|
|
|
|
|
|
|
/// \brief Check whether we detected a valid GCC install.
|
|
|
|
bool isValid() const { return IsValid; }
|
|
|
|
|
|
|
|
/// \brief Get the GCC triple for the detected install.
|
2012-01-25 03:28:29 +08:00
|
|
|
const llvm::Triple &getTriple() const { return GCCTriple; }
|
2011-11-07 07:39:34 +08:00
|
|
|
|
|
|
|
/// \brief Get the detected GCC installation path.
|
2012-01-25 03:21:42 +08:00
|
|
|
StringRef getInstallPath() const { return GCCInstallPath; }
|
2011-11-07 07:39:34 +08:00
|
|
|
|
Make a major refactoring to how the GCC installation detection works.
The fundamental shift here is to stop making *any* assumptions about the
*host* triple. Where these assumptions you ask? Why, they were in one of
the two target triples referenced of course. This was the single biggest
place where the previously named "host triple" was actually used as
such. ;] The reason we were reasoning about the host is in order to
detect the use of '-m32' or '-m64' flags to change the target. These
flags shift the default target only slightly, which typically means
a slight deviation from the host. When using these flags, the GCC
installation is under a different triple from the one actually targeted
in the compilation, and we used the host triple to find it.
Too bad that wasn't even correct. Consider an x86 Linux host which has
a PPC64 cross-compiling GCC toolchain installed. This toolchain is also
configured for multiarch compiling and can target PPC32 with eth '-m32'
flag. When targeting 'powerpc-linux-gnu' or some other PPC32 triple, we
have to look for the PPC64 variant of the triple to find the GCC
install, and that triple is neither the host nor target.
The new logic computes the multiarch's alternate triple from the target
triple, and looks under both sides. It also looks more aggressively for
the correct subdirectory of the GCC installation, and exposes the
subdirectory in a nice programmatic way. This '/32' or '/64' suffix is
something we can reuse in many other parts of the toolchain.
An important note -- while this likely fixes a large category of
cross-compile use cases, that's not my primary goal, and I've not done
testing (or added test cases) for scenarios that may now work. If
someone else wants to try more interesting PPC cross compiles, I'd love
to have reports. But my focus is on factoring away the references to the
"host" triple. The refactoring is my goal, and so I'm mostly relying on
the existing (pretty good) test coverage we have here.
Future patches will leverage this new functionality to factor out more
and more of the toolchain's triple manipulation.
llvm-svn: 148935
2012-01-25 15:21:38 +08:00
|
|
|
/// \brief Get the detected GCC installation path suffix for multiarch GCCs.
|
|
|
|
StringRef getMultiarchSuffix() const { return GCCMultiarchSuffix; }
|
|
|
|
|
2011-11-07 07:39:34 +08:00
|
|
|
/// \brief Get the detected GCC parent lib path.
|
2012-01-25 03:21:42 +08:00
|
|
|
StringRef getParentLibPath() const { return GCCParentLibPath; }
|
2011-11-07 07:39:34 +08:00
|
|
|
|
|
|
|
/// \brief Get the detected GCC version string.
|
2012-06-19 09:26:10 +08:00
|
|
|
const GCCVersion &getVersion() const { return Version; }
|
2011-11-07 07:39:34 +08:00
|
|
|
|
|
|
|
private:
|
Make a major refactoring to how the GCC installation detection works.
The fundamental shift here is to stop making *any* assumptions about the
*host* triple. Where these assumptions you ask? Why, they were in one of
the two target triples referenced of course. This was the single biggest
place where the previously named "host triple" was actually used as
such. ;] The reason we were reasoning about the host is in order to
detect the use of '-m32' or '-m64' flags to change the target. These
flags shift the default target only slightly, which typically means
a slight deviation from the host. When using these flags, the GCC
installation is under a different triple from the one actually targeted
in the compilation, and we used the host triple to find it.
Too bad that wasn't even correct. Consider an x86 Linux host which has
a PPC64 cross-compiling GCC toolchain installed. This toolchain is also
configured for multiarch compiling and can target PPC32 with eth '-m32'
flag. When targeting 'powerpc-linux-gnu' or some other PPC32 triple, we
have to look for the PPC64 variant of the triple to find the GCC
install, and that triple is neither the host nor target.
The new logic computes the multiarch's alternate triple from the target
triple, and looks under both sides. It also looks more aggressively for
the correct subdirectory of the GCC installation, and exposes the
subdirectory in a nice programmatic way. This '/32' or '/64' suffix is
something we can reuse in many other parts of the toolchain.
An important note -- while this likely fixes a large category of
cross-compile use cases, that's not my primary goal, and I've not done
testing (or added test cases) for scenarios that may now work. If
someone else wants to try more interesting PPC cross compiles, I'd love
to have reports. But my focus is on factoring away the references to the
"host" triple. The refactoring is my goal, and so I'm mostly relying on
the existing (pretty good) test coverage we have here.
Future patches will leverage this new functionality to factor out more
and more of the toolchain's triple manipulation.
llvm-svn: 148935
2012-01-25 15:21:38 +08:00
|
|
|
static void CollectLibDirsAndTriples(
|
|
|
|
const llvm::Triple &TargetTriple,
|
|
|
|
const llvm::Triple &MultiarchTriple,
|
|
|
|
SmallVectorImpl<StringRef> &LibDirs,
|
|
|
|
SmallVectorImpl<StringRef> &TripleAliases,
|
|
|
|
SmallVectorImpl<StringRef> &MultiarchLibDirs,
|
|
|
|
SmallVectorImpl<StringRef> &MultiarchTripleAliases);
|
|
|
|
|
|
|
|
void ScanLibDirForGCCTriple(llvm::Triple::ArchType TargetArch,
|
2012-10-21 19:44:57 +08:00
|
|
|
const ArgList &Args,
|
2011-11-09 11:46:20 +08:00
|
|
|
const std::string &LibDir,
|
Make a major refactoring to how the GCC installation detection works.
The fundamental shift here is to stop making *any* assumptions about the
*host* triple. Where these assumptions you ask? Why, they were in one of
the two target triples referenced of course. This was the single biggest
place where the previously named "host triple" was actually used as
such. ;] The reason we were reasoning about the host is in order to
detect the use of '-m32' or '-m64' flags to change the target. These
flags shift the default target only slightly, which typically means
a slight deviation from the host. When using these flags, the GCC
installation is under a different triple from the one actually targeted
in the compilation, and we used the host triple to find it.
Too bad that wasn't even correct. Consider an x86 Linux host which has
a PPC64 cross-compiling GCC toolchain installed. This toolchain is also
configured for multiarch compiling and can target PPC32 with eth '-m32'
flag. When targeting 'powerpc-linux-gnu' or some other PPC32 triple, we
have to look for the PPC64 variant of the triple to find the GCC
install, and that triple is neither the host nor target.
The new logic computes the multiarch's alternate triple from the target
triple, and looks under both sides. It also looks more aggressively for
the correct subdirectory of the GCC installation, and exposes the
subdirectory in a nice programmatic way. This '/32' or '/64' suffix is
something we can reuse in many other parts of the toolchain.
An important note -- while this likely fixes a large category of
cross-compile use cases, that's not my primary goal, and I've not done
testing (or added test cases) for scenarios that may now work. If
someone else wants to try more interesting PPC cross compiles, I'd love
to have reports. But my focus is on factoring away the references to the
"host" triple. The refactoring is my goal, and so I'm mostly relying on
the existing (pretty good) test coverage we have here.
Future patches will leverage this new functionality to factor out more
and more of the toolchain's triple manipulation.
llvm-svn: 148935
2012-01-25 15:21:38 +08:00
|
|
|
StringRef CandidateTriple,
|
|
|
|
bool NeedsMultiarchSuffix = false);
|
2011-11-07 07:39:34 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
GCCInstallationDetector GCCInstallation;
|
|
|
|
|
2009-03-18 05:38:00 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
Generic_GCC(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-03-20 08:20:03 +08:00
|
|
|
~Generic_GCC();
|
2009-03-18 05:38:00 +08:00
|
|
|
|
2009-03-20 08:20:03 +08:00
|
|
|
virtual bool IsUnwindTablesDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
virtual bool isPICDefault() const;
|
2013-04-09 12:35:11 +08:00
|
|
|
virtual bool isPIEDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
virtual bool isPICDefaultForced() const;
|
2011-11-07 07:39:37 +08:00
|
|
|
|
|
|
|
protected:
|
2013-03-20 11:05:54 +08:00
|
|
|
virtual Tool *getTool(Action::ActionClass AC) const;
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
|
|
|
|
2011-11-07 07:39:37 +08:00
|
|
|
/// \name ToolChain Implementation Helper Functions
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
/// \brief Check whether the target triple's architecture is 64-bits.
|
2012-02-11 11:31:12 +08:00
|
|
|
bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
|
|
|
|
|
2011-11-07 07:39:37 +08:00
|
|
|
/// \brief Check whether the target triple's architecture is 32-bits.
|
2012-02-11 11:31:12 +08:00
|
|
|
bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
|
2011-11-07 07:39:37 +08:00
|
|
|
|
|
|
|
/// @}
|
2013-03-20 11:05:54 +08:00
|
|
|
|
|
|
|
private:
|
|
|
|
mutable OwningPtr<tools::gcc::Preprocess> Preprocess;
|
|
|
|
mutable OwningPtr<tools::gcc::Precompile> Precompile;
|
|
|
|
mutable OwningPtr<tools::gcc::Compile> Compile;
|
2009-03-18 05:38:00 +08:00
|
|
|
};
|
|
|
|
|
2011-12-13 05:14:55 +08:00
|
|
|
/// Darwin - The base Darwin tool chain.
|
2010-05-12 04:16:05 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
|
2010-08-02 13:44:07 +08:00
|
|
|
public:
|
|
|
|
/// The host version.
|
|
|
|
unsigned DarwinVersion[3];
|
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
|
|
|
virtual Tool *getTool(Action::ActionClass AC) const;
|
|
|
|
|
2010-08-02 13:44:07 +08:00
|
|
|
private:
|
2013-03-20 11:05:54 +08:00
|
|
|
mutable OwningPtr<tools::darwin::Lipo> Lipo;
|
|
|
|
mutable OwningPtr<tools::darwin::Dsymutil> Dsymutil;
|
|
|
|
mutable OwningPtr<tools::darwin::VerifyDebug> VerifyDebug;
|
|
|
|
|
2010-01-27 08:56:25 +08:00
|
|
|
/// Whether the information on the target has been initialized.
|
|
|
|
//
|
|
|
|
// FIXME: This should be eliminated. What we want to do is make this part of
|
|
|
|
// the "default target for arguments" selection process, once we get out of
|
|
|
|
// the argument translation business.
|
|
|
|
mutable bool TargetInitialized;
|
|
|
|
|
2011-04-15 13:22:18 +08:00
|
|
|
/// Whether we are targeting iPhoneOS target.
|
2010-01-27 08:56:25 +08:00
|
|
|
mutable bool TargetIsIPhoneOS;
|
2010-05-14 10:03:00 +08:00
|
|
|
|
2011-04-30 12:18:16 +08:00
|
|
|
/// Whether we are targeting the iPhoneOS simulator target.
|
|
|
|
mutable bool TargetIsIPhoneOSSimulator;
|
|
|
|
|
2011-04-15 13:22:18 +08:00
|
|
|
/// The OS version we are targeting.
|
2012-03-11 04:55:36 +08:00
|
|
|
mutable VersionTuple TargetVersion;
|
2010-01-27 08:56:25 +08:00
|
|
|
|
2012-06-20 14:18:46 +08:00
|
|
|
private:
|
2009-03-27 00:23:12 +08:00
|
|
|
/// The default macosx-version-min of this tool chain; empty until
|
|
|
|
/// initialized.
|
2010-01-26 09:45:19 +08:00
|
|
|
std::string MacosxVersionMin;
|
2009-03-27 00:23:12 +08:00
|
|
|
|
2012-05-10 02:37:26 +08:00
|
|
|
/// The default ios-version-min of this tool chain; empty until
|
|
|
|
/// initialized.
|
|
|
|
std::string iOSVersionMin;
|
|
|
|
|
2010-07-20 01:11:33 +08:00
|
|
|
private:
|
2010-07-20 01:11:36 +08:00
|
|
|
void AddDeploymentTarget(DerivedArgList &Args) const;
|
2010-07-20 01:11:33 +08:00
|
|
|
|
2009-03-20 08:57:52 +08:00
|
|
|
public:
|
2013-03-19 02:10:27 +08:00
|
|
|
Darwin(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-09-05 02:34:51 +08:00
|
|
|
~Darwin();
|
2009-03-20 08:57:52 +08:00
|
|
|
|
2011-09-21 04:44:06 +08:00
|
|
|
std::string ComputeEffectiveClangTriple(const ArgList &Args,
|
|
|
|
types::ID InputType) const;
|
2010-08-24 06:35:37 +08:00
|
|
|
|
2009-09-18 16:14:36 +08:00
|
|
|
/// @name Darwin Specific Toolchain API
|
|
|
|
/// {
|
|
|
|
|
2010-01-27 08:56:25 +08:00
|
|
|
// FIXME: Eliminate these ...Target functions and derive separate tool chains
|
|
|
|
// for these targets and put version in constructor.
|
2011-04-30 12:18:16 +08:00
|
|
|
void setTarget(bool IsIPhoneOS, unsigned Major, unsigned Minor,
|
|
|
|
unsigned Micro, bool IsIOSSim) const {
|
|
|
|
assert((!IsIOSSim || IsIPhoneOS) && "Unexpected deployment target!");
|
|
|
|
|
2010-01-27 08:56:25 +08:00
|
|
|
// FIXME: For now, allow reinitialization as long as values don't
|
|
|
|
// change. This will go away when we move away from argument translation.
|
2011-04-30 12:18:16 +08:00
|
|
|
if (TargetInitialized && TargetIsIPhoneOS == IsIPhoneOS &&
|
|
|
|
TargetIsIPhoneOSSimulator == IsIOSSim &&
|
2012-03-11 04:55:36 +08:00
|
|
|
TargetVersion == VersionTuple(Major, Minor, Micro))
|
2010-01-27 08:56:25 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
assert(!TargetInitialized && "Target already initialized!");
|
|
|
|
TargetInitialized = true;
|
2011-04-30 12:18:16 +08:00
|
|
|
TargetIsIPhoneOS = IsIPhoneOS;
|
|
|
|
TargetIsIPhoneOSSimulator = IsIOSSim;
|
2012-03-11 04:55:36 +08:00
|
|
|
TargetVersion = VersionTuple(Major, Minor, Micro);
|
2010-01-27 08:56:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool isTargetIPhoneOS() const {
|
|
|
|
assert(TargetInitialized && "Target not initialized!");
|
|
|
|
return TargetIsIPhoneOS;
|
|
|
|
}
|
|
|
|
|
2011-04-01 01:12:33 +08:00
|
|
|
bool isTargetIOSSimulator() const {
|
2011-04-30 12:18:16 +08:00
|
|
|
assert(TargetInitialized && "Target not initialized!");
|
|
|
|
return TargetIsIPhoneOSSimulator;
|
2011-04-01 01:12:33 +08:00
|
|
|
}
|
|
|
|
|
2012-03-07 04:05:56 +08:00
|
|
|
bool isTargetMacOS() const {
|
2012-11-09 09:59:30 +08:00
|
|
|
return !isTargetIOSSimulator() && !isTargetIPhoneOS();
|
2012-03-07 04:05:56 +08:00
|
|
|
}
|
|
|
|
|
2010-03-20 08:50:21 +08:00
|
|
|
bool isTargetInitialized() const { return TargetInitialized; }
|
|
|
|
|
2012-03-11 04:55:36 +08:00
|
|
|
VersionTuple getTargetVersion() const {
|
2010-01-27 08:56:25 +08:00
|
|
|
assert(TargetInitialized && "Target not initialized!");
|
2012-03-11 04:55:36 +08:00
|
|
|
return TargetVersion;
|
2010-01-27 08:56:25 +08:00
|
|
|
}
|
|
|
|
|
2010-01-22 10:04:58 +08:00
|
|
|
/// getDarwinArchName - Get the "Darwin" arch name for a particular compiler
|
|
|
|
/// invocation. For example, Darwin treats different ARM variations as
|
|
|
|
/// distinct architectures.
|
2011-07-20 14:58:45 +08:00
|
|
|
StringRef getDarwinArchName(const ArgList &Args) const;
|
2010-01-22 10:04:58 +08:00
|
|
|
|
2010-01-27 08:57:03 +08:00
|
|
|
bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
|
|
|
|
assert(isTargetIPhoneOS() && "Unexpected call for OS X target!");
|
2012-03-11 04:55:36 +08:00
|
|
|
return TargetVersion < VersionTuple(V0, V1, V2);
|
2009-09-18 16:14:55 +08:00
|
|
|
}
|
|
|
|
|
2010-01-27 08:57:03 +08:00
|
|
|
bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const {
|
|
|
|
assert(!isTargetIPhoneOS() && "Unexpected call for iPhoneOS target!");
|
2012-03-11 04:55:36 +08:00
|
|
|
return TargetVersion < VersionTuple(V0, V1, V2);
|
2010-01-27 08:56:56 +08:00
|
|
|
}
|
|
|
|
|
2011-06-16 07:02:42 +08:00
|
|
|
/// AddLinkARCArgs - Add the linker arguments to link the ARC runtime library.
|
|
|
|
virtual void AddLinkARCArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const = 0;
|
|
|
|
|
2009-09-18 16:15:03 +08:00
|
|
|
/// AddLinkRuntimeLibArgs - Add the linker arguments to link the compiler
|
|
|
|
/// runtime library.
|
2009-09-18 16:15:13 +08:00
|
|
|
virtual void AddLinkRuntimeLibArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const = 0;
|
2011-06-23 01:41:40 +08:00
|
|
|
|
2009-09-18 16:14:36 +08:00
|
|
|
/// }
|
|
|
|
/// @name ToolChain Implementation
|
|
|
|
/// {
|
|
|
|
|
2010-08-02 13:43:56 +08:00
|
|
|
virtual types::ID LookupTypeForExtension(const char *Ext) const;
|
|
|
|
|
2010-09-17 08:24:52 +08:00
|
|
|
virtual bool HasNativeLLVMSupport() const;
|
|
|
|
|
2012-06-20 14:18:46 +08:00
|
|
|
virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const;
|
2011-09-10 04:41:01 +08:00
|
|
|
virtual bool hasBlocksRuntime() const;
|
2011-06-16 07:02:42 +08:00
|
|
|
|
2010-06-12 06:00:26 +08:00
|
|
|
virtual DerivedArgList *TranslateArgs(const DerivedArgList &Args,
|
2009-09-10 02:36:12 +08:00
|
|
|
const char *BoundArch) const;
|
2009-03-20 08:57:52 +08:00
|
|
|
|
2009-11-17 16:07:36 +08:00
|
|
|
virtual bool IsBlocksDefault() const {
|
2010-07-22 08:40:31 +08:00
|
|
|
// Always allow blocks on Darwin; users interested in versioning are
|
|
|
|
// expected to use /usr/include/Blocks.h.
|
|
|
|
return true;
|
2009-11-17 16:07:36 +08:00
|
|
|
}
|
2010-05-14 10:03:00 +08:00
|
|
|
virtual bool IsIntegratedAssemblerDefault() const {
|
2010-06-24 02:15:13 +08:00
|
|
|
#ifdef DISABLE_DEFAULT_INTEGRATED_ASSEMBLER
|
|
|
|
return false;
|
|
|
|
#else
|
2012-02-28 07:55:25 +08:00
|
|
|
// Default integrated assembler to on for Darwin.
|
|
|
|
return true;
|
2010-06-24 02:15:13 +08:00
|
|
|
#endif
|
2010-05-14 10:03:00 +08:00
|
|
|
}
|
2011-02-04 10:20:39 +08:00
|
|
|
virtual bool IsStrictAliasingDefault() const {
|
|
|
|
#ifdef DISABLE_DEFAULT_STRICT_ALIASING
|
|
|
|
return false;
|
|
|
|
#else
|
|
|
|
return ToolChain::IsStrictAliasingDefault();
|
|
|
|
#endif
|
|
|
|
}
|
2012-05-02 22:55:48 +08:00
|
|
|
|
|
|
|
virtual bool IsMathErrnoDefault() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-11-16 03:02:45 +08:00
|
|
|
virtual bool IsEncodeExtendedBlockSignatureDefault() const {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-11-17 16:07:36 +08:00
|
|
|
virtual bool IsObjCNonFragileABIDefault() const {
|
2010-04-25 02:37:41 +08:00
|
|
|
// Non-fragile ABI is default for everything but i386.
|
|
|
|
return getTriple().getArch() != llvm::Triple::x86;
|
2009-11-17 16:07:36 +08:00
|
|
|
}
|
2010-04-25 02:37:41 +08:00
|
|
|
|
2010-04-25 01:56:46 +08:00
|
|
|
virtual bool UseObjCMixedDispatch() const {
|
2010-04-25 02:37:41 +08:00
|
|
|
// This is only used with the non-fragile ABI and non-legacy dispatch.
|
|
|
|
|
|
|
|
// Mixed dispatch is used everywhere except OS X before 10.6.
|
|
|
|
return !(!isTargetIPhoneOS() && isMacosxVersionLT(10, 6));
|
2010-04-25 01:56:46 +08:00
|
|
|
}
|
2009-03-20 08:57:52 +08:00
|
|
|
virtual bool IsUnwindTablesDefault() const;
|
2011-08-23 15:38:27 +08:00
|
|
|
virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
|
|
|
|
// Stack protectors default to on for user code on 10.5,
|
|
|
|
// and for everything in 10.6 and beyond
|
2011-12-14 14:08:25 +08:00
|
|
|
return isTargetIPhoneOS() ||
|
2011-08-23 15:38:27 +08:00
|
|
|
(!isMacosxVersionLT(10, 6) ||
|
|
|
|
(!isMacosxVersionLT(10, 5) && !KernelOrKext));
|
2009-11-17 16:07:36 +08:00
|
|
|
}
|
2011-12-08 07:03:15 +08:00
|
|
|
virtual RuntimeLibType GetDefaultRuntimeLibType() const {
|
|
|
|
return ToolChain::RLT_CompilerRT;
|
|
|
|
}
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
virtual bool isPICDefault() const;
|
2013-04-09 12:35:11 +08:00
|
|
|
virtual bool isPIEDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
virtual bool isPICDefaultForced() const;
|
2009-09-18 16:14:36 +08:00
|
|
|
|
2011-03-02 02:49:30 +08:00
|
|
|
virtual bool SupportsProfiling() const;
|
|
|
|
|
2010-04-11 00:20:23 +08:00
|
|
|
virtual bool SupportsObjCGC() const;
|
|
|
|
|
2012-08-21 10:47:43 +08:00
|
|
|
virtual void CheckObjCARC() const;
|
2012-02-29 11:43:52 +08:00
|
|
|
|
2009-12-18 10:43:17 +08:00
|
|
|
virtual bool UseDwarfDebugFlags() const;
|
|
|
|
|
2010-02-11 02:49:11 +08:00
|
|
|
virtual bool UseSjLjExceptions() const;
|
|
|
|
|
2009-09-18 16:14:36 +08:00
|
|
|
/// }
|
2009-03-20 08:57:52 +08:00
|
|
|
};
|
|
|
|
|
2009-09-18 16:15:13 +08:00
|
|
|
/// DarwinClang - The Darwin toolchain used by Clang.
|
2010-05-12 04:16:05 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
|
2009-09-18 16:15:13 +08:00
|
|
|
public:
|
2013-03-19 02:10:27 +08:00
|
|
|
DarwinClang(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-09-18 16:15:13 +08:00
|
|
|
|
|
|
|
/// @name Darwin ToolChain Implementation
|
|
|
|
/// {
|
|
|
|
|
|
|
|
virtual void AddLinkRuntimeLibArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const;
|
2012-11-21 22:17:42 +08:00
|
|
|
void AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
|
|
|
|
const char *DarwinStaticLib,
|
|
|
|
bool AlwaysLink = false) const;
|
|
|
|
|
2010-09-17 09:20:05 +08:00
|
|
|
virtual void AddCXXStdlibLibArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const;
|
2010-09-17 09:16:06 +08:00
|
|
|
|
2010-09-18 02:39:08 +08:00
|
|
|
virtual void AddCCKextLibArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const;
|
|
|
|
|
2011-06-16 07:02:42 +08:00
|
|
|
virtual void AddLinkARCArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const;
|
2009-09-18 16:15:13 +08:00
|
|
|
/// }
|
|
|
|
};
|
|
|
|
|
|
|
|
/// Darwin_Generic_GCC - Generic Darwin tool chain using gcc.
|
2010-05-12 04:16:05 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Darwin_Generic_GCC : public Generic_GCC {
|
2009-03-20 08:57:52 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
Darwin_Generic_GCC(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
|
|
|
|
: Generic_GCC(D, Triple, Args) {}
|
2009-03-20 08:57:52 +08:00
|
|
|
|
2011-09-21 04:44:06 +08:00
|
|
|
std::string ComputeEffectiveClangTriple(const ArgList &Args,
|
|
|
|
types::ID InputType) const;
|
2010-08-24 06:35:37 +08:00
|
|
|
|
2012-11-28 01:31:26 +08:00
|
|
|
virtual bool isPICDefault() const { return false; }
|
2009-03-20 08:57:52 +08:00
|
|
|
};
|
|
|
|
|
2010-10-30 04:14:02 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
|
2011-12-20 10:48:34 +08:00
|
|
|
virtual void anchor();
|
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
Generic_ELF(const Driver &D, const llvm::Triple& Triple, const ArgList &Args)
|
|
|
|
: Generic_GCC(D, Triple, Args) {}
|
2010-10-30 04:14:02 +08:00
|
|
|
|
|
|
|
virtual bool IsIntegratedAssemblerDefault() const {
|
|
|
|
// Default integrated assembler to on for x86.
|
2013-01-31 20:13:10 +08:00
|
|
|
return (getTriple().getArch() == llvm::Triple::aarch64 ||
|
|
|
|
getTriple().getArch() == llvm::Triple::x86 ||
|
2010-10-30 04:14:02 +08:00
|
|
|
getTriple().getArch() == llvm::Triple::x86_64);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-05-12 04:16:05 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY AuroraUX : public Generic_GCC {
|
2009-08-22 09:06:46 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
AuroraUX(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-08-22 09:06:46 +08:00
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2009-08-22 09:06:46 +08:00
|
|
|
};
|
|
|
|
|
2012-02-15 21:39:01 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC {
|
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
Solaris(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2012-02-15 21:39:01 +08:00
|
|
|
|
|
|
|
virtual bool IsIntegratedAssemblerDefault() const { return true; }
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
|
|
|
|
2012-02-15 21:39:01 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-10-30 04:14:02 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
|
2009-06-30 04:52:51 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-06-30 04:52:51 +08:00
|
|
|
|
2012-05-02 22:55:48 +08:00
|
|
|
virtual bool IsMathErrnoDefault() const { return false; }
|
2012-04-09 20:33:41 +08:00
|
|
|
virtual bool IsObjCNonFragileABIDefault() const { return true; }
|
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2009-06-30 04:52:51 +08:00
|
|
|
};
|
|
|
|
|
2012-08-09 07:57:20 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
|
|
|
|
public:
|
|
|
|
Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
|
|
|
|
|
|
|
virtual bool IsMathErrnoDefault() const { return false; }
|
|
|
|
virtual bool IsObjCNonFragileABIDefault() const { return true; }
|
|
|
|
virtual bool IsObjCLegacyDispatchDefault() const { return false; }
|
|
|
|
|
|
|
|
virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
|
|
|
virtual void AddCXXStdlibLibArgs(const ArgList &Args,
|
|
|
|
ArgStringList &CmdArgs) const;
|
|
|
|
virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
|
|
|
|
return 1;
|
|
|
|
}
|
2013-03-20 11:05:54 +08:00
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2012-08-09 07:57:20 +08:00
|
|
|
};
|
|
|
|
|
2010-10-30 04:14:02 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF {
|
2009-03-31 05:06:03 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-03-31 05:06:03 +08:00
|
|
|
|
2012-05-02 22:55:48 +08:00
|
|
|
virtual bool IsMathErrnoDefault() const { return false; }
|
2012-04-09 20:33:41 +08:00
|
|
|
virtual bool IsObjCNonFragileABIDefault() const { return true; }
|
|
|
|
|
2012-12-13 12:17:14 +08:00
|
|
|
virtual bool UseSjLjExceptions() const;
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2009-03-31 05:06:03 +08:00
|
|
|
};
|
|
|
|
|
2011-02-03 02:59:27 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF {
|
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2011-02-03 02:59:27 +08:00
|
|
|
|
2012-05-02 22:55:48 +08:00
|
|
|
virtual bool IsMathErrnoDefault() const { return false; }
|
2012-04-09 20:33:41 +08:00
|
|
|
virtual bool IsObjCNonFragileABIDefault() const { return true; }
|
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2011-02-03 02:59:27 +08:00
|
|
|
};
|
|
|
|
|
2011-12-09 07:54:21 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF {
|
2010-07-08 00:01:42 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2010-07-08 00:01:42 +08:00
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2010-07-08 00:01:42 +08:00
|
|
|
};
|
|
|
|
|
2010-10-30 04:14:02 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF {
|
2009-05-03 02:28:39 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2009-05-03 02:28:39 +08:00
|
|
|
|
2012-05-02 22:55:48 +08:00
|
|
|
virtual bool IsMathErrnoDefault() const { return false; }
|
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2009-05-03 02:28:39 +08:00
|
|
|
};
|
|
|
|
|
2010-10-30 04:14:02 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
|
2009-05-26 15:52:18 +08:00
|
|
|
public:
|
2012-02-19 09:38:32 +08:00
|
|
|
Linux(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2010-08-10 08:25:48 +08:00
|
|
|
|
2010-11-08 04:14:31 +08:00
|
|
|
virtual bool HasNativeLLVMSupport() const;
|
|
|
|
|
2011-11-06 04:17:13 +08:00
|
|
|
virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
2012-11-22 07:40:23 +08:00
|
|
|
virtual void addClangTargetOptions(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
2011-11-06 04:17:13 +08:00
|
|
|
virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
2013-04-09 12:35:11 +08:00
|
|
|
virtual bool isPIEDefault() const;
|
2011-11-06 04:17:13 +08:00
|
|
|
|
2010-11-08 04:14:31 +08:00
|
|
|
std::string Linker;
|
|
|
|
std::vector<std::string> ExtraOpts;
|
2013-04-09 12:35:11 +08:00
|
|
|
bool IsPIEDefault;
|
2011-12-18 07:10:01 +08:00
|
|
|
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
|
|
|
|
2011-12-18 07:10:01 +08:00
|
|
|
private:
|
2013-03-07 01:14:05 +08:00
|
|
|
static bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix,
|
|
|
|
Twine TargetArchDir,
|
|
|
|
Twine MultiLibSuffix,
|
|
|
|
const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args);
|
2011-12-18 07:10:01 +08:00
|
|
|
static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,
|
|
|
|
const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args);
|
2013-04-20 16:15:03 +08:00
|
|
|
|
|
|
|
std::string computeSysRoot(const ArgList &Args) const;
|
2009-05-26 15:52:18 +08:00
|
|
|
};
|
|
|
|
|
2012-12-06 20:43:18 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public Linux {
|
|
|
|
protected:
|
|
|
|
GCCVersion GCCLibAndIncVersion;
|
2013-03-20 11:05:54 +08:00
|
|
|
virtual Tool *buildAssembler() const;
|
|
|
|
virtual Tool *buildLinker() const;
|
2012-12-06 20:43:18 +08:00
|
|
|
|
|
|
|
public:
|
|
|
|
Hexagon_TC(const Driver &D, const llvm::Triple &Triple,
|
|
|
|
const ArgList &Args);
|
|
|
|
~Hexagon_TC();
|
|
|
|
|
|
|
|
virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
|
|
|
virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
2012-12-06 23:46:07 +08:00
|
|
|
virtual CXXStdlibType GetCXXStdlibType(const ArgList &Args) const;
|
2012-12-06 20:43:18 +08:00
|
|
|
|
|
|
|
StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; }
|
|
|
|
|
|
|
|
static std::string GetGnuDir(const std::string &InstalledDir);
|
2012-12-06 22:16:43 +08:00
|
|
|
|
|
|
|
static StringRef GetTargetCPU(const ArgList &Args);
|
2012-12-06 20:43:18 +08:00
|
|
|
};
|
2009-05-26 15:52:18 +08:00
|
|
|
|
2010-03-05 05:07:38 +08:00
|
|
|
/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
|
|
|
|
/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.
|
2010-05-12 04:16:05 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain {
|
2010-03-05 05:07:38 +08:00
|
|
|
public:
|
2013-03-19 02:10:27 +08:00
|
|
|
TCEToolChain(const Driver &D, const llvm::Triple& Triple,
|
|
|
|
const ArgList &Args);
|
2010-03-05 05:07:38 +08:00
|
|
|
~TCEToolChain();
|
|
|
|
|
|
|
|
bool IsMathErrnoDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
bool isPICDefault() const;
|
2013-04-09 12:35:11 +08:00
|
|
|
bool isPIEDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
bool isPICDefaultForced() const;
|
2010-03-05 05:07:38 +08:00
|
|
|
};
|
|
|
|
|
2010-08-22 05:55:07 +08:00
|
|
|
class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {
|
|
|
|
public:
|
2013-03-19 02:10:27 +08:00
|
|
|
Windows(const Driver &D, const llvm::Triple& Triple, const ArgList &Args);
|
2010-08-22 05:55:07 +08:00
|
|
|
|
|
|
|
virtual bool IsIntegratedAssemblerDefault() const;
|
|
|
|
virtual bool IsUnwindTablesDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
virtual bool isPICDefault() const;
|
2013-04-09 12:35:11 +08:00
|
|
|
virtual bool isPIEDefault() const;
|
Completely re-work how the Clang driver interprets PIC and PIE options.
There were numerous issues here that were all entangled, and so I've
tried to do a general simplification of the logic.
1) The logic was mimicing actual GCC bugs, rather than "features". These
have been fixed in trunk GCC, and this fixes Clang as well. Notably,
the logic was always intended to be last-match-wins like any other
flag.
2) The logic for handling '-mdynamic-no-pic' was preposterously unclear.
It also allowed the use of this flag on non-Darwin platforms where it
has no actual meaning. Now this option is handled directly based on
tests of how llvm-gcc behaves, and it is only supported on Darwin.
3) The APIs for the Driver's ToolChains had the implementation ugliness
of dynamic-no-pic leaking through them. They also had the
implementation details of the LLVM relocation model flag names
leaking through.
4) The actual results of passing these flags was incorrect on Darwin in
many cases. For example, Darwin *always* uses PIC level 2 if it uses
in PIC level, and Darwin *always* uses PIC on 64-bit regardless of
the flags specified, including -fPIE. Darwin never compiles in PIE
mode, but it can *link* in PIE mode.
5) Also, PIC was not always being enabled even when PIE was. This isn't
a supported mode at all and may have caused some fallout in builds
with complex PIC and PIE interactions.
The result is (I hope) cleaner and clearer for readers. I've also left
comments and tests about some of the truly strage behavior that is
observed on Darwin platforms. We have no real testing of Windows
platforms and PIC, but I don't have the tools handy to figure that out.
Hopefully others can beef up our testing here.
Unfortunately, I can't test this for every platform. =/ If folks have
dependencies on these flags that aren't covered by tests, they may
break. I've audited and ensured that all the changes in behavior of the
existing tests are intentional and good. In particular I've tried to
make sure the Darwin behavior (which is more suprising than the Linux
behavior) also matches that of 'gcc' on my mac.
llvm-svn: 168297
2012-11-19 11:52:03 +08:00
|
|
|
virtual bool isPICDefaultForced() const;
|
2011-11-05 07:49:05 +08:00
|
|
|
|
|
|
|
virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
|
|
|
virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
|
|
|
|
ArgStringList &CC1Args) const;
|
2013-03-20 11:05:54 +08:00
|
|
|
protected:
|
|
|
|
virtual Tool *buildLinker() const;
|
|
|
|
virtual Tool *buildAssembler() const;
|
2010-08-22 05:55:07 +08:00
|
|
|
};
|
|
|
|
|
2009-03-18 05:38:00 +08:00
|
|
|
} // end namespace toolchains
|
|
|
|
} // end namespace driver
|
|
|
|
} // end namespace clang
|
|
|
|
|
|
|
|
#endif
|