Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 1 | //===--- ToolChains.h - ToolChain Implementations ---------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #ifndef CLANG_LIB_DRIVER_TOOLCHAINS_H_ |
| 11 | #define CLANG_LIB_DRIVER_TOOLCHAINS_H_ |
| 12 | |
Daniel Dunbar | 670b7f4 | 2009-03-17 22:07:31 +0000 | [diff] [blame] | 13 | #include "clang/Driver/Action.h" |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 14 | #include "clang/Driver/ToolChain.h" |
| 15 | |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 16 | #include "clang/Basic/VersionTuple.h" |
Daniel Dunbar | 670b7f4 | 2009-03-17 22:07:31 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/DenseMap.h" |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 18 | #include "llvm/Support/Compiler.h" |
| 19 | |
Daniel Dunbar | 670b7f4 | 2009-03-17 22:07:31 +0000 | [diff] [blame] | 20 | #include "Tools.h" |
| 21 | |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 22 | namespace clang { |
| 23 | namespace driver { |
Daniel Dunbar | 985b825 | 2009-03-17 22:18:43 +0000 | [diff] [blame] | 24 | namespace toolchains { |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 25 | |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 26 | /// Generic_GCC - A tool chain using the 'gcc' command to perform |
| 27 | /// all subcommands; this relies on gcc translating the majority of |
| 28 | /// command line options. |
Duncan Sands | 92dd191 | 2010-05-11 20:16:05 +0000 | [diff] [blame] | 29 | class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain { |
Daniel Dunbar | 75358d2 | 2009-03-30 21:06:03 +0000 | [diff] [blame] | 30 | protected: |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 31 | /// \brief Struct to store and manipulate GCC versions. |
| 32 | /// |
| 33 | /// We rely on assumptions about the form and structure of GCC version |
| 34 | /// numbers: they consist of at most three '.'-separated components, and each |
| 35 | /// component is a non-negative integer except for the last component. For |
| 36 | /// the last component we are very flexible in order to tolerate release |
| 37 | /// candidates or 'x' wildcards. |
| 38 | /// |
| 39 | /// Note that the ordering established among GCCVersions is based on the |
| 40 | /// preferred version string to use. For example we prefer versions without |
| 41 | /// a hard-coded patch number to those with a hard coded patch number. |
| 42 | /// |
| 43 | /// Currently this doesn't provide any logic for textual suffixes to patches |
| 44 | /// in the way that (for example) Debian's version format does. If that ever |
| 45 | /// becomes necessary, it can be added. |
| 46 | struct GCCVersion { |
| 47 | /// \brief The unparsed text of the version. |
| 48 | std::string Text; |
| 49 | |
| 50 | /// \brief The parsed major, minor, and patch numbers. |
| 51 | int Major, Minor, Patch; |
| 52 | |
| 53 | /// \brief Any textual suffix on the patch number. |
| 54 | std::string PatchSuffix; |
| 55 | |
| 56 | static GCCVersion Parse(StringRef VersionText); |
| 57 | bool operator<(const GCCVersion &RHS) const; |
| 58 | bool operator>(const GCCVersion &RHS) const { return RHS < *this; } |
| 59 | bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); } |
| 60 | bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); } |
| 61 | }; |
| 62 | |
| 63 | |
| 64 | /// \brief This is a class to find a viable GCC installation for Clang to |
| 65 | /// use. |
| 66 | /// |
| 67 | /// This class tries to find a GCC installation on the system, and report |
| 68 | /// information about it. It starts from the host information provided to the |
| 69 | /// Driver, and has logic for fuzzing that where appropriate. |
| 70 | class GCCInstallationDetector { |
| 71 | |
| 72 | bool IsValid; |
Chandler Carruth | fa5be91 | 2012-01-24 19:28:29 +0000 | [diff] [blame] | 73 | llvm::Triple GCCTriple; |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 74 | |
| 75 | // FIXME: These might be better as path objects. |
Chandler Carruth | 5d84bb4 | 2012-01-24 19:21:42 +0000 | [diff] [blame] | 76 | std::string GCCInstallPath; |
Chandler Carruth | 1c6f04a | 2012-01-25 07:21:38 +0000 | [diff] [blame] | 77 | std::string GCCMultiarchSuffix; |
Chandler Carruth | 5d84bb4 | 2012-01-24 19:21:42 +0000 | [diff] [blame] | 78 | std::string GCCParentLibPath; |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 79 | |
| 80 | GCCVersion Version; |
| 81 | |
| 82 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 83 | GCCInstallationDetector(const Driver &D, const llvm::Triple &TargetTriple, |
| 84 | const ArgList &Args); |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 85 | |
| 86 | /// \brief Check whether we detected a valid GCC install. |
| 87 | bool isValid() const { return IsValid; } |
| 88 | |
| 89 | /// \brief Get the GCC triple for the detected install. |
Chandler Carruth | fa5be91 | 2012-01-24 19:28:29 +0000 | [diff] [blame] | 90 | const llvm::Triple &getTriple() const { return GCCTriple; } |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 91 | |
| 92 | /// \brief Get the detected GCC installation path. |
Chandler Carruth | 5d84bb4 | 2012-01-24 19:21:42 +0000 | [diff] [blame] | 93 | StringRef getInstallPath() const { return GCCInstallPath; } |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 94 | |
Chandler Carruth | 1c6f04a | 2012-01-25 07:21:38 +0000 | [diff] [blame] | 95 | /// \brief Get the detected GCC installation path suffix for multiarch GCCs. |
| 96 | StringRef getMultiarchSuffix() const { return GCCMultiarchSuffix; } |
| 97 | |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 98 | /// \brief Get the detected GCC parent lib path. |
Chandler Carruth | 5d84bb4 | 2012-01-24 19:21:42 +0000 | [diff] [blame] | 99 | StringRef getParentLibPath() const { return GCCParentLibPath; } |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 100 | |
| 101 | /// \brief Get the detected GCC version string. |
| 102 | StringRef getVersion() const { return Version.Text; } |
| 103 | |
| 104 | private: |
Chandler Carruth | 1c6f04a | 2012-01-25 07:21:38 +0000 | [diff] [blame] | 105 | static void CollectLibDirsAndTriples( |
| 106 | const llvm::Triple &TargetTriple, |
| 107 | const llvm::Triple &MultiarchTriple, |
| 108 | SmallVectorImpl<StringRef> &LibDirs, |
| 109 | SmallVectorImpl<StringRef> &TripleAliases, |
| 110 | SmallVectorImpl<StringRef> &MultiarchLibDirs, |
| 111 | SmallVectorImpl<StringRef> &MultiarchTripleAliases); |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 112 | |
Chandler Carruth | 1c6f04a | 2012-01-25 07:21:38 +0000 | [diff] [blame] | 113 | void ScanLibDirForGCCTriple(llvm::Triple::ArchType TargetArch, |
Chandler Carruth | d936d9d | 2011-11-09 03:46:20 +0000 | [diff] [blame] | 114 | const std::string &LibDir, |
Chandler Carruth | 1c6f04a | 2012-01-25 07:21:38 +0000 | [diff] [blame] | 115 | StringRef CandidateTriple, |
| 116 | bool NeedsMultiarchSuffix = false); |
Chandler Carruth | 19347ed | 2011-11-06 23:39:34 +0000 | [diff] [blame] | 117 | }; |
| 118 | |
| 119 | GCCInstallationDetector GCCInstallation; |
| 120 | |
Daniel Dunbar | 670b7f4 | 2009-03-17 22:07:31 +0000 | [diff] [blame] | 121 | mutable llvm::DenseMap<unsigned, Tool*> Tools; |
| 122 | |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 123 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 124 | Generic_GCC(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Daniel Dunbar | 3917608 | 2009-03-20 00:20:03 +0000 | [diff] [blame] | 125 | ~Generic_GCC(); |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 126 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 127 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 128 | const ActionList &Inputs) const; |
Daniel Dunbar | 670b7f4 | 2009-03-17 22:07:31 +0000 | [diff] [blame] | 129 | |
Daniel Dunbar | 3917608 | 2009-03-20 00:20:03 +0000 | [diff] [blame] | 130 | virtual bool IsUnwindTablesDefault() const; |
| 131 | virtual const char *GetDefaultRelocationModel() const; |
| 132 | virtual const char *GetForcedPicModel() const; |
Chandler Carruth | b37fe61 | 2011-11-06 23:39:37 +0000 | [diff] [blame] | 133 | |
| 134 | protected: |
| 135 | /// \name ToolChain Implementation Helper Functions |
| 136 | /// @{ |
| 137 | |
| 138 | /// \brief Check whether the target triple's architecture is 64-bits. |
Chandler Carruth | d747efa | 2012-02-11 03:31:12 +0000 | [diff] [blame] | 139 | bool isTarget64Bit() const { return getTriple().isArch64Bit(); } |
| 140 | |
Chandler Carruth | b37fe61 | 2011-11-06 23:39:37 +0000 | [diff] [blame] | 141 | /// \brief Check whether the target triple's architecture is 32-bits. |
Chandler Carruth | d747efa | 2012-02-11 03:31:12 +0000 | [diff] [blame] | 142 | bool isTarget32Bit() const { return getTriple().isArch32Bit(); } |
Chandler Carruth | b37fe61 | 2011-11-06 23:39:37 +0000 | [diff] [blame] | 143 | |
| 144 | /// @} |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 145 | }; |
| 146 | |
Tony Linthicum | 9631939 | 2011-12-12 21:14:55 +0000 | [diff] [blame] | 147 | class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public ToolChain { |
| 148 | protected: |
| 149 | mutable llvm::DenseMap<unsigned, Tool*> Tools; |
| 150 | |
| 151 | public: |
Chandler Carruth | 1d16f0f | 2012-01-31 02:21:20 +0000 | [diff] [blame] | 152 | Hexagon_TC(const Driver &D, const llvm::Triple& Triple); |
Tony Linthicum | 9631939 | 2011-12-12 21:14:55 +0000 | [diff] [blame] | 153 | ~Hexagon_TC(); |
| 154 | |
| 155 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 156 | const ActionList &Inputs) const; |
| 157 | |
| 158 | virtual bool IsUnwindTablesDefault() const; |
| 159 | virtual const char *GetDefaultRelocationModel() const; |
| 160 | virtual const char *GetForcedPicModel() const; |
| 161 | }; |
| 162 | |
| 163 | /// Darwin - The base Darwin tool chain. |
Duncan Sands | 92dd191 | 2010-05-11 20:16:05 +0000 | [diff] [blame] | 164 | class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain { |
Daniel Dunbar | 25b58eb | 2010-08-02 05:44:07 +0000 | [diff] [blame] | 165 | public: |
| 166 | /// The host version. |
| 167 | unsigned DarwinVersion[3]; |
| 168 | |
| 169 | private: |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 170 | mutable llvm::DenseMap<unsigned, Tool*> Tools; |
| 171 | |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 172 | /// Whether the information on the target has been initialized. |
| 173 | // |
| 174 | // FIXME: This should be eliminated. What we want to do is make this part of |
| 175 | // the "default target for arguments" selection process, once we get out of |
| 176 | // the argument translation business. |
| 177 | mutable bool TargetInitialized; |
| 178 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 179 | // FIXME: Remove this once there is a proper way to detect an ARC runtime |
| 180 | // for the simulator. |
| 181 | public: |
| 182 | mutable enum { |
| 183 | ARCSimulator_None, |
| 184 | ARCSimulator_HasARCRuntime, |
| 185 | ARCSimulator_NoARCRuntime |
| 186 | } ARCRuntimeForSimulator; |
| 187 | |
Bob Wilson | 163b151 | 2011-10-07 17:54:41 +0000 | [diff] [blame] | 188 | mutable enum { |
| 189 | LibCXXSimulator_None, |
| 190 | LibCXXSimulator_NotAvailable, |
| 191 | LibCXXSimulator_Available |
| 192 | } LibCXXForSimulator; |
| 193 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 194 | private: |
Chris Lattner | fc8f0e1 | 2011-04-15 05:22:18 +0000 | [diff] [blame] | 195 | /// Whether we are targeting iPhoneOS target. |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 196 | mutable bool TargetIsIPhoneOS; |
Daniel Dunbar | eb840bd | 2010-05-14 02:03:00 +0000 | [diff] [blame] | 197 | |
Daniel Dunbar | 5f5c37b | 2011-04-30 04:18:16 +0000 | [diff] [blame] | 198 | /// Whether we are targeting the iPhoneOS simulator target. |
| 199 | mutable bool TargetIsIPhoneOSSimulator; |
| 200 | |
Chris Lattner | fc8f0e1 | 2011-04-15 05:22:18 +0000 | [diff] [blame] | 201 | /// The OS version we are targeting. |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 202 | mutable VersionTuple TargetVersion; |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 203 | |
Daniel Dunbar | 02633b5 | 2009-03-26 16:23:12 +0000 | [diff] [blame] | 204 | /// The default macosx-version-min of this tool chain; empty until |
| 205 | /// initialized. |
Daniel Dunbar | 816bc31 | 2010-01-26 01:45:19 +0000 | [diff] [blame] | 206 | std::string MacosxVersionMin; |
Daniel Dunbar | 02633b5 | 2009-03-26 16:23:12 +0000 | [diff] [blame] | 207 | |
Chad Rosier | 4ec2678 | 2012-05-09 18:37:26 +0000 | [diff] [blame^] | 208 | /// The default ios-version-min of this tool chain; empty until |
| 209 | /// initialized. |
| 210 | std::string iOSVersionMin; |
| 211 | |
John McCall | 9f084a3 | 2011-07-06 00:26:06 +0000 | [diff] [blame] | 212 | bool hasARCRuntime() const; |
Ted Kremenek | ebcb57a | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 213 | bool hasSubscriptingRuntime() const; |
John McCall | 9f084a3 | 2011-07-06 00:26:06 +0000 | [diff] [blame] | 214 | |
Daniel Dunbar | c0e665e | 2010-07-19 17:11:33 +0000 | [diff] [blame] | 215 | private: |
Daniel Dunbar | 60baf0f | 2010-07-19 17:11:36 +0000 | [diff] [blame] | 216 | void AddDeploymentTarget(DerivedArgList &Args) const; |
Daniel Dunbar | c0e665e | 2010-07-19 17:11:33 +0000 | [diff] [blame] | 217 | |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 218 | public: |
Chandler Carruth | 1d16f0f | 2012-01-31 02:21:20 +0000 | [diff] [blame] | 219 | Darwin(const Driver &D, const llvm::Triple& Triple); |
Daniel Dunbar | f395528 | 2009-09-04 18:34:51 +0000 | [diff] [blame] | 220 | ~Darwin(); |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 221 | |
Chad Rosier | 61ab80a | 2011-09-20 20:44:06 +0000 | [diff] [blame] | 222 | std::string ComputeEffectiveClangTriple(const ArgList &Args, |
| 223 | types::ID InputType) const; |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 224 | |
Daniel Dunbar | 6b200b2 | 2009-09-18 08:14:36 +0000 | [diff] [blame] | 225 | /// @name Darwin Specific Toolchain API |
| 226 | /// { |
| 227 | |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 228 | // FIXME: Eliminate these ...Target functions and derive separate tool chains |
| 229 | // for these targets and put version in constructor. |
Daniel Dunbar | 5f5c37b | 2011-04-30 04:18:16 +0000 | [diff] [blame] | 230 | void setTarget(bool IsIPhoneOS, unsigned Major, unsigned Minor, |
| 231 | unsigned Micro, bool IsIOSSim) const { |
| 232 | assert((!IsIOSSim || IsIPhoneOS) && "Unexpected deployment target!"); |
| 233 | |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 234 | // FIXME: For now, allow reinitialization as long as values don't |
| 235 | // change. This will go away when we move away from argument translation. |
Daniel Dunbar | 5f5c37b | 2011-04-30 04:18:16 +0000 | [diff] [blame] | 236 | if (TargetInitialized && TargetIsIPhoneOS == IsIPhoneOS && |
| 237 | TargetIsIPhoneOSSimulator == IsIOSSim && |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 238 | TargetVersion == VersionTuple(Major, Minor, Micro)) |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 239 | return; |
| 240 | |
| 241 | assert(!TargetInitialized && "Target already initialized!"); |
| 242 | TargetInitialized = true; |
Daniel Dunbar | 5f5c37b | 2011-04-30 04:18:16 +0000 | [diff] [blame] | 243 | TargetIsIPhoneOS = IsIPhoneOS; |
| 244 | TargetIsIPhoneOSSimulator = IsIOSSim; |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 245 | TargetVersion = VersionTuple(Major, Minor, Micro); |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | bool isTargetIPhoneOS() const { |
| 249 | assert(TargetInitialized && "Target not initialized!"); |
| 250 | return TargetIsIPhoneOS; |
| 251 | } |
| 252 | |
Daniel Dunbar | 4035580 | 2011-03-31 17:12:33 +0000 | [diff] [blame] | 253 | bool isTargetIOSSimulator() const { |
Daniel Dunbar | 5f5c37b | 2011-04-30 04:18:16 +0000 | [diff] [blame] | 254 | assert(TargetInitialized && "Target not initialized!"); |
| 255 | return TargetIsIPhoneOSSimulator; |
Daniel Dunbar | 4035580 | 2011-03-31 17:12:33 +0000 | [diff] [blame] | 256 | } |
| 257 | |
Ted Kremenek | ebcb57a | 2012-03-06 20:05:56 +0000 | [diff] [blame] | 258 | bool isTargetMacOS() const { |
| 259 | return !isTargetIOSSimulator() && |
| 260 | !isTargetIPhoneOS() && |
| 261 | ARCRuntimeForSimulator == ARCSimulator_None; |
| 262 | } |
| 263 | |
Daniel Dunbar | 03d87ee | 2010-03-20 00:50:21 +0000 | [diff] [blame] | 264 | bool isTargetInitialized() const { return TargetInitialized; } |
| 265 | |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 266 | VersionTuple getTargetVersion() const { |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 267 | assert(TargetInitialized && "Target not initialized!"); |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 268 | return TargetVersion; |
Daniel Dunbar | 2603137 | 2010-01-27 00:56:25 +0000 | [diff] [blame] | 269 | } |
| 270 | |
Daniel Dunbar | eeff406 | 2010-01-22 02:04:58 +0000 | [diff] [blame] | 271 | /// getDarwinArchName - Get the "Darwin" arch name for a particular compiler |
| 272 | /// invocation. For example, Darwin treats different ARM variations as |
| 273 | /// distinct architectures. |
Chris Lattner | 686775d | 2011-07-20 06:58:45 +0000 | [diff] [blame] | 274 | StringRef getDarwinArchName(const ArgList &Args) const; |
Daniel Dunbar | eeff406 | 2010-01-22 02:04:58 +0000 | [diff] [blame] | 275 | |
Daniel Dunbar | cacb0f0 | 2010-01-27 00:56:56 +0000 | [diff] [blame] | 276 | bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const { |
| 277 | assert(isTargetIPhoneOS() && "Unexpected call for OS X target!"); |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 278 | return TargetVersion < VersionTuple(V0, V1, V2); |
Daniel Dunbar | ce3fdf2 | 2010-01-27 00:57:03 +0000 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const { |
| 282 | assert(!isTargetIPhoneOS() && "Unexpected call for iPhoneOS target!"); |
Benjamin Kramer | 09c9a56 | 2012-03-10 20:55:36 +0000 | [diff] [blame] | 283 | return TargetVersion < VersionTuple(V0, V1, V2); |
Daniel Dunbar | cacb0f0 | 2010-01-27 00:56:56 +0000 | [diff] [blame] | 284 | } |
| 285 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 286 | /// AddLinkARCArgs - Add the linker arguments to link the ARC runtime library. |
| 287 | virtual void AddLinkARCArgs(const ArgList &Args, |
| 288 | ArgStringList &CmdArgs) const = 0; |
| 289 | |
Daniel Dunbar | 6cd4154 | 2009-09-18 08:15:03 +0000 | [diff] [blame] | 290 | /// AddLinkRuntimeLibArgs - Add the linker arguments to link the compiler |
| 291 | /// runtime library. |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 292 | virtual void AddLinkRuntimeLibArgs(const ArgList &Args, |
| 293 | ArgStringList &CmdArgs) const = 0; |
Eric Christopher | 3404fe7 | 2011-06-22 17:41:40 +0000 | [diff] [blame] | 294 | |
Daniel Dunbar | 6b200b2 | 2009-09-18 08:14:36 +0000 | [diff] [blame] | 295 | /// } |
| 296 | /// @name ToolChain Implementation |
| 297 | /// { |
| 298 | |
Daniel Dunbar | 4180011 | 2010-08-02 05:43:56 +0000 | [diff] [blame] | 299 | virtual types::ID LookupTypeForExtension(const char *Ext) const; |
| 300 | |
Daniel Dunbar | b993f5d | 2010-09-17 00:24:52 +0000 | [diff] [blame] | 301 | virtual bool HasNativeLLVMSupport() const; |
| 302 | |
John McCall | 9f084a3 | 2011-07-06 00:26:06 +0000 | [diff] [blame] | 303 | virtual void configureObjCRuntime(ObjCRuntime &runtime) const; |
John McCall | 13db5cf | 2011-09-09 20:41:01 +0000 | [diff] [blame] | 304 | virtual bool hasBlocksRuntime() const; |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 305 | |
Daniel Dunbar | 279c1db | 2010-06-11 22:00:26 +0000 | [diff] [blame] | 306 | virtual DerivedArgList *TranslateArgs(const DerivedArgList &Args, |
Daniel Dunbar | 0dcb9a3 | 2009-09-09 18:36:12 +0000 | [diff] [blame] | 307 | const char *BoundArch) const; |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 308 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 309 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 310 | const ActionList &Inputs) const; |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 311 | |
Daniel Dunbar | 9e5cc6b | 2009-11-17 08:07:36 +0000 | [diff] [blame] | 312 | virtual bool IsBlocksDefault() const { |
Daniel Dunbar | ef44a5d | 2010-07-22 00:40:31 +0000 | [diff] [blame] | 313 | // Always allow blocks on Darwin; users interested in versioning are |
| 314 | // expected to use /usr/include/Blocks.h. |
| 315 | return true; |
Daniel Dunbar | 9e5cc6b | 2009-11-17 08:07:36 +0000 | [diff] [blame] | 316 | } |
Daniel Dunbar | eb840bd | 2010-05-14 02:03:00 +0000 | [diff] [blame] | 317 | virtual bool IsIntegratedAssemblerDefault() const { |
Daniel Dunbar | 71a6cbc | 2010-06-23 18:15:13 +0000 | [diff] [blame] | 318 | #ifdef DISABLE_DEFAULT_INTEGRATED_ASSEMBLER |
| 319 | return false; |
| 320 | #else |
Jim Grosbach | 033d300 | 2012-02-27 23:55:25 +0000 | [diff] [blame] | 321 | // Default integrated assembler to on for Darwin. |
| 322 | return true; |
Daniel Dunbar | 71a6cbc | 2010-06-23 18:15:13 +0000 | [diff] [blame] | 323 | #endif |
Daniel Dunbar | eb840bd | 2010-05-14 02:03:00 +0000 | [diff] [blame] | 324 | } |
Daniel Dunbar | 398c610 | 2011-02-04 02:20:39 +0000 | [diff] [blame] | 325 | virtual bool IsStrictAliasingDefault() const { |
| 326 | #ifdef DISABLE_DEFAULT_STRICT_ALIASING |
| 327 | return false; |
| 328 | #else |
| 329 | return ToolChain::IsStrictAliasingDefault(); |
| 330 | #endif |
| 331 | } |
Benjamin Kramer | 769aa2d | 2012-05-02 14:55:48 +0000 | [diff] [blame] | 332 | |
| 333 | virtual bool IsMathErrnoDefault() const { |
| 334 | return false; |
| 335 | } |
| 336 | |
Ted Kremenek | c32647d | 2010-12-23 21:35:43 +0000 | [diff] [blame] | 337 | virtual bool IsObjCDefaultSynthPropertiesDefault() const { |
Ted Kremenek | 2a25396 | 2012-03-06 20:06:15 +0000 | [diff] [blame] | 338 | return true; |
Ted Kremenek | c32647d | 2010-12-23 21:35:43 +0000 | [diff] [blame] | 339 | } |
| 340 | |
Daniel Dunbar | 9e5cc6b | 2009-11-17 08:07:36 +0000 | [diff] [blame] | 341 | virtual bool IsObjCNonFragileABIDefault() const { |
Daniel Dunbar | f645aaa | 2010-04-24 18:37:41 +0000 | [diff] [blame] | 342 | // Non-fragile ABI is default for everything but i386. |
| 343 | return getTriple().getArch() != llvm::Triple::x86; |
Daniel Dunbar | 9e5cc6b | 2009-11-17 08:07:36 +0000 | [diff] [blame] | 344 | } |
Daniel Dunbar | 609508c | 2010-02-01 21:07:43 +0000 | [diff] [blame] | 345 | virtual bool IsObjCLegacyDispatchDefault() const { |
| 346 | // This is only used with the non-fragile ABI. |
Daniel Dunbar | f645aaa | 2010-04-24 18:37:41 +0000 | [diff] [blame] | 347 | |
| 348 | // Legacy dispatch is used everywhere except on x86_64. |
| 349 | return getTriple().getArch() != llvm::Triple::x86_64; |
Daniel Dunbar | 609508c | 2010-02-01 21:07:43 +0000 | [diff] [blame] | 350 | } |
Daniel Dunbar | f643b9b | 2010-04-24 17:56:46 +0000 | [diff] [blame] | 351 | virtual bool UseObjCMixedDispatch() const { |
Daniel Dunbar | f645aaa | 2010-04-24 18:37:41 +0000 | [diff] [blame] | 352 | // This is only used with the non-fragile ABI and non-legacy dispatch. |
| 353 | |
| 354 | // Mixed dispatch is used everywhere except OS X before 10.6. |
| 355 | return !(!isTargetIPhoneOS() && isMacosxVersionLT(10, 6)); |
Daniel Dunbar | f643b9b | 2010-04-24 17:56:46 +0000 | [diff] [blame] | 356 | } |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 357 | virtual bool IsUnwindTablesDefault() const; |
Nico Weber | 2fef111 | 2011-08-23 07:38:27 +0000 | [diff] [blame] | 358 | virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const { |
| 359 | // Stack protectors default to on for user code on 10.5, |
| 360 | // and for everything in 10.6 and beyond |
Bob Wilson | dfba027 | 2011-12-14 06:08:25 +0000 | [diff] [blame] | 361 | return isTargetIPhoneOS() || |
Nico Weber | 2fef111 | 2011-08-23 07:38:27 +0000 | [diff] [blame] | 362 | (!isMacosxVersionLT(10, 6) || |
| 363 | (!isMacosxVersionLT(10, 5) && !KernelOrKext)); |
Daniel Dunbar | 9e5cc6b | 2009-11-17 08:07:36 +0000 | [diff] [blame] | 364 | } |
Daniel Dunbar | c24767c | 2011-12-07 23:03:15 +0000 | [diff] [blame] | 365 | virtual RuntimeLibType GetDefaultRuntimeLibType() const { |
| 366 | return ToolChain::RLT_CompilerRT; |
| 367 | } |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 368 | virtual const char *GetDefaultRelocationModel() const; |
| 369 | virtual const char *GetForcedPicModel() const; |
Daniel Dunbar | 6b200b2 | 2009-09-18 08:14:36 +0000 | [diff] [blame] | 370 | |
Daniel Dunbar | bbe8e3e | 2011-03-01 18:49:30 +0000 | [diff] [blame] | 371 | virtual bool SupportsProfiling() const; |
| 372 | |
Daniel Dunbar | 43a9b32 | 2010-04-10 16:20:23 +0000 | [diff] [blame] | 373 | virtual bool SupportsObjCGC() const; |
| 374 | |
Argyrios Kyrtzidis | 5840dd9 | 2012-02-29 03:43:52 +0000 | [diff] [blame] | 375 | virtual bool SupportsObjCARC() const; |
| 376 | |
Daniel Dunbar | f2d8b9f | 2009-12-18 02:43:17 +0000 | [diff] [blame] | 377 | virtual bool UseDwarfDebugFlags() const; |
| 378 | |
Daniel Dunbar | b2987d1 | 2010-02-10 18:49:11 +0000 | [diff] [blame] | 379 | virtual bool UseSjLjExceptions() const; |
| 380 | |
Daniel Dunbar | 6b200b2 | 2009-09-18 08:14:36 +0000 | [diff] [blame] | 381 | /// } |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 382 | }; |
| 383 | |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 384 | /// DarwinClang - The Darwin toolchain used by Clang. |
Duncan Sands | 92dd191 | 2010-05-11 20:16:05 +0000 | [diff] [blame] | 385 | class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin { |
Bob Wilson | 8aa76ea | 2011-09-20 22:00:38 +0000 | [diff] [blame] | 386 | private: |
| 387 | void AddGCCLibexecPath(unsigned darwinVersion); |
| 388 | |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 389 | public: |
Chandler Carruth | 1d16f0f | 2012-01-31 02:21:20 +0000 | [diff] [blame] | 390 | DarwinClang(const Driver &D, const llvm::Triple& Triple); |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 391 | |
| 392 | /// @name Darwin ToolChain Implementation |
| 393 | /// { |
| 394 | |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 395 | virtual void AddLinkRuntimeLibArgs(const ArgList &Args, |
| 396 | ArgStringList &CmdArgs) const; |
Eric Christopher | 3404fe7 | 2011-06-22 17:41:40 +0000 | [diff] [blame] | 397 | void AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs, |
| 398 | const char *DarwinStaticLib) const; |
| 399 | |
Daniel Dunbar | 132e35d | 2010-09-17 01:20:05 +0000 | [diff] [blame] | 400 | virtual void AddCXXStdlibLibArgs(const ArgList &Args, |
| 401 | ArgStringList &CmdArgs) const; |
Daniel Dunbar | efe91ea | 2010-09-17 01:16:06 +0000 | [diff] [blame] | 402 | |
Shantonu Sen | 7433fed | 2010-09-17 18:39:08 +0000 | [diff] [blame] | 403 | virtual void AddCCKextLibArgs(const ArgList &Args, |
| 404 | ArgStringList &CmdArgs) const; |
| 405 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 406 | virtual void AddLinkARCArgs(const ArgList &Args, |
| 407 | ArgStringList &CmdArgs) const; |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 408 | /// } |
| 409 | }; |
| 410 | |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 411 | /// Darwin_Generic_GCC - Generic Darwin tool chain using gcc. |
Duncan Sands | 92dd191 | 2010-05-11 20:16:05 +0000 | [diff] [blame] | 412 | class LLVM_LIBRARY_VISIBILITY Darwin_Generic_GCC : public Generic_GCC { |
Daniel Dunbar | 1d4612b | 2009-09-18 08:15:13 +0000 | [diff] [blame] | 413 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 414 | Darwin_Generic_GCC(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) |
| 415 | : Generic_GCC(D, Triple, Args) {} |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 416 | |
Chad Rosier | 61ab80a | 2011-09-20 20:44:06 +0000 | [diff] [blame] | 417 | std::string ComputeEffectiveClangTriple(const ArgList &Args, |
| 418 | types::ID InputType) const; |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 419 | |
Daniel Dunbar | 8eddb3f | 2009-03-20 00:57:52 +0000 | [diff] [blame] | 420 | virtual const char *GetDefaultRelocationModel() const { return "pic"; } |
| 421 | }; |
| 422 | |
Rafael Espindola | e43cfa1 | 2010-10-29 20:14:02 +0000 | [diff] [blame] | 423 | class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC { |
David Blaikie | 99ba9e3 | 2011-12-20 02:48:34 +0000 | [diff] [blame] | 424 | virtual void anchor(); |
| 425 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 426 | Generic_ELF(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) |
| 427 | : Generic_GCC(D, Triple, Args) {} |
Rafael Espindola | e43cfa1 | 2010-10-29 20:14:02 +0000 | [diff] [blame] | 428 | |
| 429 | virtual bool IsIntegratedAssemblerDefault() const { |
| 430 | // Default integrated assembler to on for x86. |
| 431 | return (getTriple().getArch() == llvm::Triple::x86 || |
| 432 | getTriple().getArch() == llvm::Triple::x86_64); |
| 433 | } |
| 434 | }; |
| 435 | |
Duncan Sands | 92dd191 | 2010-05-11 20:16:05 +0000 | [diff] [blame] | 436 | class LLVM_LIBRARY_VISIBILITY AuroraUX : public Generic_GCC { |
Edward O'Callaghan | e7925a0 | 2009-08-22 01:06:46 +0000 | [diff] [blame] | 437 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 438 | AuroraUX(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Edward O'Callaghan | e7925a0 | 2009-08-22 01:06:46 +0000 | [diff] [blame] | 439 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 440 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 441 | const ActionList &Inputs) const; |
Edward O'Callaghan | e7925a0 | 2009-08-22 01:06:46 +0000 | [diff] [blame] | 442 | }; |
| 443 | |
David Chisnall | 31c4690 | 2012-02-15 13:39:01 +0000 | [diff] [blame] | 444 | class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC { |
| 445 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 446 | Solaris(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
David Chisnall | 31c4690 | 2012-02-15 13:39:01 +0000 | [diff] [blame] | 447 | |
| 448 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 449 | const ActionList &Inputs) const; |
| 450 | |
| 451 | virtual bool IsIntegratedAssemblerDefault() const { return true; } |
| 452 | }; |
| 453 | |
| 454 | |
Rafael Espindola | e43cfa1 | 2010-10-29 20:14:02 +0000 | [diff] [blame] | 455 | class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF { |
Daniel Dunbar | f7b8eec | 2009-06-29 20:52:51 +0000 | [diff] [blame] | 456 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 457 | OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Daniel Dunbar | f7b8eec | 2009-06-29 20:52:51 +0000 | [diff] [blame] | 458 | |
Benjamin Kramer | 769aa2d | 2012-05-02 14:55:48 +0000 | [diff] [blame] | 459 | virtual bool IsMathErrnoDefault() const { return false; } |
David Chisnall | c3cb072 | 2012-04-09 12:33:41 +0000 | [diff] [blame] | 460 | virtual bool IsObjCNonFragileABIDefault() const { return true; } |
| 461 | virtual bool IsObjCLegacyDispatchDefault() const { |
| 462 | llvm::Triple::ArchType Arch = getTriple().getArch(); |
| 463 | if (Arch == llvm::Triple::arm || |
| 464 | Arch == llvm::Triple::x86 || |
| 465 | Arch == llvm::Triple::x86_64) |
| 466 | return false; |
| 467 | return true; |
| 468 | } |
| 469 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 470 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 471 | const ActionList &Inputs) const; |
Daniel Dunbar | f7b8eec | 2009-06-29 20:52:51 +0000 | [diff] [blame] | 472 | }; |
| 473 | |
Rafael Espindola | e43cfa1 | 2010-10-29 20:14:02 +0000 | [diff] [blame] | 474 | class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF { |
Daniel Dunbar | 75358d2 | 2009-03-30 21:06:03 +0000 | [diff] [blame] | 475 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 476 | FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Daniel Dunbar | 75358d2 | 2009-03-30 21:06:03 +0000 | [diff] [blame] | 477 | |
Benjamin Kramer | 769aa2d | 2012-05-02 14:55:48 +0000 | [diff] [blame] | 478 | virtual bool IsMathErrnoDefault() const { return false; } |
David Chisnall | c3cb072 | 2012-04-09 12:33:41 +0000 | [diff] [blame] | 479 | virtual bool IsObjCNonFragileABIDefault() const { return true; } |
| 480 | virtual bool IsObjCLegacyDispatchDefault() const { |
| 481 | llvm::Triple::ArchType Arch = getTriple().getArch(); |
| 482 | if (Arch == llvm::Triple::arm || |
| 483 | Arch == llvm::Triple::x86 || |
| 484 | Arch == llvm::Triple::x86_64) |
| 485 | return false; |
| 486 | return true; |
| 487 | } |
| 488 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 489 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 490 | const ActionList &Inputs) const; |
Daniel Dunbar | 75358d2 | 2009-03-30 21:06:03 +0000 | [diff] [blame] | 491 | }; |
| 492 | |
Benjamin Kramer | 8e50a96 | 2011-02-02 18:59:27 +0000 | [diff] [blame] | 493 | class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF { |
| 494 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 495 | NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Benjamin Kramer | 8e50a96 | 2011-02-02 18:59:27 +0000 | [diff] [blame] | 496 | |
Benjamin Kramer | 769aa2d | 2012-05-02 14:55:48 +0000 | [diff] [blame] | 497 | virtual bool IsMathErrnoDefault() const { return false; } |
David Chisnall | c3cb072 | 2012-04-09 12:33:41 +0000 | [diff] [blame] | 498 | virtual bool IsObjCNonFragileABIDefault() const { return true; } |
| 499 | virtual bool IsObjCLegacyDispatchDefault() const { |
| 500 | llvm::Triple::ArchType Arch = getTriple().getArch(); |
| 501 | if (Arch == llvm::Triple::arm || |
| 502 | Arch == llvm::Triple::x86 || |
| 503 | Arch == llvm::Triple::x86_64) |
| 504 | return false; |
| 505 | return true; |
| 506 | } |
| 507 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 508 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 509 | const ActionList &Inputs) const; |
Benjamin Kramer | 8e50a96 | 2011-02-02 18:59:27 +0000 | [diff] [blame] | 510 | }; |
| 511 | |
Eli Friedman | 6d402dc | 2011-12-08 23:54:21 +0000 | [diff] [blame] | 512 | class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF { |
Chris Lattner | 38e317d | 2010-07-07 16:01:42 +0000 | [diff] [blame] | 513 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 514 | Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Chris Lattner | 38e317d | 2010-07-07 16:01:42 +0000 | [diff] [blame] | 515 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 516 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 517 | const ActionList &Inputs) const; |
Chris Lattner | 38e317d | 2010-07-07 16:01:42 +0000 | [diff] [blame] | 518 | }; |
| 519 | |
Rafael Espindola | e43cfa1 | 2010-10-29 20:14:02 +0000 | [diff] [blame] | 520 | class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF { |
Daniel Dunbar | 11e1b40 | 2009-05-02 18:28:39 +0000 | [diff] [blame] | 521 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 522 | DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Daniel Dunbar | 11e1b40 | 2009-05-02 18:28:39 +0000 | [diff] [blame] | 523 | |
Benjamin Kramer | 769aa2d | 2012-05-02 14:55:48 +0000 | [diff] [blame] | 524 | virtual bool IsMathErrnoDefault() const { return false; } |
| 525 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 526 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 527 | const ActionList &Inputs) const; |
Daniel Dunbar | 11e1b40 | 2009-05-02 18:28:39 +0000 | [diff] [blame] | 528 | }; |
| 529 | |
Rafael Espindola | e43cfa1 | 2010-10-29 20:14:02 +0000 | [diff] [blame] | 530 | class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF { |
Eli Friedman | 6b3454a | 2009-05-26 07:52:18 +0000 | [diff] [blame] | 531 | public: |
Rafael Espindola | 0e65959 | 2012-02-19 01:38:32 +0000 | [diff] [blame] | 532 | Linux(const Driver &D, const llvm::Triple& Triple, const ArgList &Args); |
Rafael Espindola | ba30bbe | 2010-08-10 00:25:48 +0000 | [diff] [blame] | 533 | |
Rafael Espindola | c1da981 | 2010-11-07 20:14:31 +0000 | [diff] [blame] | 534 | virtual bool HasNativeLLVMSupport() const; |
| 535 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 536 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 537 | const ActionList &Inputs) const; |
Rafael Espindola | c1da981 | 2010-11-07 20:14:31 +0000 | [diff] [blame] | 538 | |
Chandler Carruth | 7d7e9f9 | 2011-11-05 20:17:13 +0000 | [diff] [blame] | 539 | virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs, |
| 540 | ArgStringList &CC1Args) const; |
| 541 | virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, |
| 542 | ArgStringList &CC1Args) const; |
| 543 | |
Rafael Espindola | c1da981 | 2010-11-07 20:14:31 +0000 | [diff] [blame] | 544 | std::string Linker; |
| 545 | std::vector<std::string> ExtraOpts; |
Chandler Carruth | 79cbbdc | 2011-12-17 23:10:01 +0000 | [diff] [blame] | 546 | |
| 547 | private: |
| 548 | static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir, |
| 549 | const ArgList &DriverArgs, |
| 550 | ArgStringList &CC1Args); |
Eli Friedman | 6b3454a | 2009-05-26 07:52:18 +0000 | [diff] [blame] | 551 | }; |
| 552 | |
| 553 | |
Chris Lattner | 3a47c4e | 2010-03-04 21:07:38 +0000 | [diff] [blame] | 554 | /// TCEToolChain - A tool chain using the llvm bitcode tools to perform |
| 555 | /// all subcommands. See http://tce.cs.tut.fi for our peculiar target. |
Duncan Sands | 92dd191 | 2010-05-11 20:16:05 +0000 | [diff] [blame] | 556 | class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain { |
Chris Lattner | 3a47c4e | 2010-03-04 21:07:38 +0000 | [diff] [blame] | 557 | public: |
Chandler Carruth | 1d16f0f | 2012-01-31 02:21:20 +0000 | [diff] [blame] | 558 | TCEToolChain(const Driver &D, const llvm::Triple& Triple); |
Chris Lattner | 3a47c4e | 2010-03-04 21:07:38 +0000 | [diff] [blame] | 559 | ~TCEToolChain(); |
| 560 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 561 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 562 | const ActionList &Inputs) const; |
Chris Lattner | 3a47c4e | 2010-03-04 21:07:38 +0000 | [diff] [blame] | 563 | bool IsMathErrnoDefault() const; |
| 564 | bool IsUnwindTablesDefault() const; |
| 565 | const char* GetDefaultRelocationModel() const; |
| 566 | const char* GetForcedPicModel() const; |
| 567 | |
| 568 | private: |
| 569 | mutable llvm::DenseMap<unsigned, Tool*> Tools; |
| 570 | |
| 571 | }; |
| 572 | |
Michael J. Spencer | ff58e36 | 2010-08-21 21:55:07 +0000 | [diff] [blame] | 573 | class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain { |
| 574 | mutable llvm::DenseMap<unsigned, Tool*> Tools; |
| 575 | |
| 576 | public: |
Chandler Carruth | 1d16f0f | 2012-01-31 02:21:20 +0000 | [diff] [blame] | 577 | Windows(const Driver &D, const llvm::Triple& Triple); |
Michael J. Spencer | ff58e36 | 2010-08-21 21:55:07 +0000 | [diff] [blame] | 578 | |
Daniel Dunbar | ac0659a | 2011-03-18 20:14:00 +0000 | [diff] [blame] | 579 | virtual Tool &SelectTool(const Compilation &C, const JobAction &JA, |
| 580 | const ActionList &Inputs) const; |
Michael J. Spencer | ff58e36 | 2010-08-21 21:55:07 +0000 | [diff] [blame] | 581 | |
| 582 | virtual bool IsIntegratedAssemblerDefault() const; |
| 583 | virtual bool IsUnwindTablesDefault() const; |
| 584 | virtual const char *GetDefaultRelocationModel() const; |
| 585 | virtual const char *GetForcedPicModel() const; |
Chandler Carruth | ca23419 | 2011-11-04 23:49:05 +0000 | [diff] [blame] | 586 | |
| 587 | virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs, |
| 588 | ArgStringList &CC1Args) const; |
| 589 | virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, |
| 590 | ArgStringList &CC1Args) const; |
| 591 | |
Michael J. Spencer | ff58e36 | 2010-08-21 21:55:07 +0000 | [diff] [blame] | 592 | }; |
| 593 | |
Daniel Dunbar | 83b08eb | 2009-03-17 21:38:00 +0000 | [diff] [blame] | 594 | } // end namespace toolchains |
| 595 | } // end namespace driver |
| 596 | } // end namespace clang |
| 597 | |
| 598 | #endif |