Nick Lewycky | 3fdcc6f | 2010-12-31 17:31:54 +0000 | [diff] [blame] | 1 | //===--- ToolChain.cpp - Collections of tools for one platform ------------===// |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 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 | |
Rafael Espindola | 5b22205 | 2013-03-18 20:48:54 +0000 | [diff] [blame] | 10 | #include "Tools.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 11 | #include "clang/Basic/ObjCRuntime.h" |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 12 | #include "clang/Driver/Action.h" |
| 13 | #include "clang/Driver/Driver.h" |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 14 | #include "clang/Driver/DriverDiagnostic.h" |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 15 | #include "clang/Driver/Options.h" |
Reid Kleckner | b1e25a1 | 2013-06-14 17:17:23 +0000 | [diff] [blame] | 16 | #include "clang/Driver/ToolChain.h" |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/StringSwitch.h" |
Reid Kleckner | b1e25a1 | 2013-06-14 17:17:23 +0000 | [diff] [blame] | 18 | #include "llvm/Option/Arg.h" |
| 19 | #include "llvm/Option/ArgList.h" |
| 20 | #include "llvm/Option/Option.h" |
John McCall | 9f084a3 | 2011-07-06 00:26:06 +0000 | [diff] [blame] | 21 | #include "llvm/Support/ErrorHandling.h" |
Simon Atanasyan | 8e8e95c | 2013-04-20 08:15:03 +0000 | [diff] [blame] | 22 | #include "llvm/Support/FileSystem.h" |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 23 | using namespace clang::driver; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 24 | using namespace clang; |
Reid Kleckner | b1e25a1 | 2013-06-14 17:17:23 +0000 | [diff] [blame] | 25 | using namespace llvm::opt; |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 26 | |
Rafael Espindola | af370e6 | 2013-03-18 18:10:27 +0000 | [diff] [blame] | 27 | ToolChain::ToolChain(const Driver &D, const llvm::Triple &T, |
| 28 | const ArgList &A) |
| 29 | : D(D), Triple(T), Args(A) { |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 30 | } |
| 31 | |
| 32 | ToolChain::~ToolChain() { |
| 33 | } |
| 34 | |
Daniel Dunbar | ee788e7 | 2009-12-21 18:54:17 +0000 | [diff] [blame] | 35 | const Driver &ToolChain::getDriver() const { |
Chandler Carruth | 4d7ff6e | 2012-01-25 09:12:06 +0000 | [diff] [blame] | 36 | return D; |
Daniel Dunbar | ee788e7 | 2009-12-21 18:54:17 +0000 | [diff] [blame] | 37 | } |
| 38 | |
Rafael Espindola | af370e6 | 2013-03-18 18:10:27 +0000 | [diff] [blame] | 39 | bool ToolChain::useIntegratedAs() const { |
Rafael Espindola | 5470cd2 | 2013-03-18 17:52:57 +0000 | [diff] [blame] | 40 | return Args.hasFlag(options::OPT_integrated_as, |
| 41 | options::OPT_no_integrated_as, |
| 42 | IsIntegratedAssemblerDefault()); |
| 43 | } |
| 44 | |
Daniel Dunbar | d2a527e | 2012-11-08 03:38:26 +0000 | [diff] [blame] | 45 | std::string ToolChain::getDefaultUniversalArchName() const { |
| 46 | // In universal driver terms, the arch name accepted by -arch isn't exactly |
| 47 | // the same as the ones that appear in the triple. Roughly speaking, this is |
| 48 | // an inverse of the darwin::getArchTypeForDarwinArchName() function, but the |
| 49 | // only interesting special case is powerpc. |
| 50 | switch (Triple.getArch()) { |
| 51 | case llvm::Triple::ppc: |
| 52 | return "ppc"; |
| 53 | case llvm::Triple::ppc64: |
| 54 | return "ppc64"; |
| 55 | default: |
| 56 | return Triple.getArchName(); |
| 57 | } |
| 58 | } |
| 59 | |
Rafael Espindola | 03a8638 | 2012-09-23 03:05:41 +0000 | [diff] [blame] | 60 | bool ToolChain::IsUnwindTablesDefault() const { |
| 61 | return false; |
| 62 | } |
| 63 | |
Rafael Espindola | f48b93c | 2013-03-20 03:05:54 +0000 | [diff] [blame] | 64 | Tool *ToolChain::getClang() const { |
| 65 | if (!Clang) |
| 66 | Clang.reset(new tools::Clang(*this)); |
| 67 | return Clang.get(); |
| 68 | } |
| 69 | |
| 70 | Tool *ToolChain::buildAssembler() const { |
| 71 | return new tools::ClangAs(*this); |
| 72 | } |
| 73 | |
| 74 | Tool *ToolChain::buildLinker() const { |
| 75 | llvm_unreachable("Linking is not supported by this toolchain"); |
| 76 | } |
| 77 | |
| 78 | Tool *ToolChain::getAssemble() const { |
| 79 | if (!Assemble) |
| 80 | Assemble.reset(buildAssembler()); |
| 81 | return Assemble.get(); |
| 82 | } |
| 83 | |
| 84 | Tool *ToolChain::getClangAs() const { |
| 85 | if (!Assemble) |
| 86 | Assemble.reset(new tools::ClangAs(*this)); |
| 87 | return Assemble.get(); |
| 88 | } |
| 89 | |
| 90 | Tool *ToolChain::getLink() const { |
| 91 | if (!Link) |
| 92 | Link.reset(buildLinker()); |
| 93 | return Link.get(); |
| 94 | } |
| 95 | |
| 96 | Tool *ToolChain::getTool(Action::ActionClass AC) const { |
Rafael Espindola | c0a55d1 | 2013-03-19 00:36:57 +0000 | [diff] [blame] | 97 | switch (AC) { |
Rafael Espindola | f48b93c | 2013-03-20 03:05:54 +0000 | [diff] [blame] | 98 | case Action::AssembleJobClass: |
| 99 | return getAssemble(); |
| 100 | |
| 101 | case Action::LinkJobClass: |
| 102 | return getLink(); |
| 103 | |
Rafael Espindola | c0a55d1 | 2013-03-19 00:36:57 +0000 | [diff] [blame] | 104 | case Action::InputClass: |
| 105 | case Action::BindArchClass: |
Rafael Espindola | c0a55d1 | 2013-03-19 00:36:57 +0000 | [diff] [blame] | 106 | case Action::LipoJobClass: |
| 107 | case Action::DsymutilJobClass: |
| 108 | case Action::VerifyJobClass: |
| 109 | llvm_unreachable("Invalid tool kind."); |
| 110 | |
| 111 | case Action::CompileJobClass: |
| 112 | case Action::PrecompileJobClass: |
| 113 | case Action::PreprocessJobClass: |
| 114 | case Action::AnalyzeJobClass: |
| 115 | case Action::MigrateJobClass: |
Rafael Espindola | f48b93c | 2013-03-20 03:05:54 +0000 | [diff] [blame] | 116 | return getClang(); |
Rafael Espindola | c0a55d1 | 2013-03-19 00:36:57 +0000 | [diff] [blame] | 117 | } |
Benjamin Kramer | 4c49f7b | 2013-03-21 19:45:46 +0000 | [diff] [blame] | 118 | |
| 119 | llvm_unreachable("Invalid tool kind."); |
Rafael Espindola | c0a55d1 | 2013-03-19 00:36:57 +0000 | [diff] [blame] | 120 | } |
| 121 | |
Rafael Espindola | 2951187 | 2013-03-24 15:06:53 +0000 | [diff] [blame] | 122 | Tool *ToolChain::SelectTool(const JobAction &JA) const { |
Rafael Espindola | 5b22205 | 2013-03-18 20:48:54 +0000 | [diff] [blame] | 123 | if (getDriver().ShouldUseClangCompiler(JA)) |
Rafael Espindola | 2951187 | 2013-03-24 15:06:53 +0000 | [diff] [blame] | 124 | return getClang(); |
Rafael Espindola | f48b93c | 2013-03-20 03:05:54 +0000 | [diff] [blame] | 125 | Action::ActionClass AC = JA.getKind(); |
| 126 | if (AC == Action::AssembleJobClass && useIntegratedAs()) |
Rafael Espindola | 2951187 | 2013-03-24 15:06:53 +0000 | [diff] [blame] | 127 | return getClangAs(); |
| 128 | return getTool(AC); |
Rafael Espindola | 5b22205 | 2013-03-18 20:48:54 +0000 | [diff] [blame] | 129 | } |
| 130 | |
Daniel Dunbar | 4a7e889 | 2010-07-14 18:46:23 +0000 | [diff] [blame] | 131 | std::string ToolChain::GetFilePath(const char *Name) const { |
Chandler Carruth | 4d7ff6e | 2012-01-25 09:12:06 +0000 | [diff] [blame] | 132 | return D.GetFilePath(Name, *this); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 133 | |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 134 | } |
| 135 | |
Simon Atanasyan | fc44e88 | 2012-10-03 19:52:37 +0000 | [diff] [blame] | 136 | std::string ToolChain::GetProgramPath(const char *Name) const { |
| 137 | return D.GetProgramPath(Name, *this); |
Daniel Dunbar | 2ba38ba | 2009-03-16 05:25:36 +0000 | [diff] [blame] | 138 | } |
Daniel Dunbar | 4180011 | 2010-08-02 05:43:56 +0000 | [diff] [blame] | 139 | |
| 140 | types::ID ToolChain::LookupTypeForExtension(const char *Ext) const { |
| 141 | return types::lookupTypeForExtension(Ext); |
| 142 | } |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 143 | |
Daniel Dunbar | b993f5d | 2010-09-17 00:24:52 +0000 | [diff] [blame] | 144 | bool ToolChain::HasNativeLLVMSupport() const { |
| 145 | return false; |
| 146 | } |
| 147 | |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 148 | ObjCRuntime ToolChain::getDefaultObjCRuntime(bool isNonFragile) const { |
David Chisnall | 11d3f4c | 2012-07-03 20:49:52 +0000 | [diff] [blame] | 149 | return ObjCRuntime(isNonFragile ? ObjCRuntime::GNUstep : ObjCRuntime::GCC, |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 150 | VersionTuple()); |
John McCall | 9f084a3 | 2011-07-06 00:26:06 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Chris Lattner | fc8f0e1 | 2011-04-15 05:22:18 +0000 | [diff] [blame] | 153 | /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting. |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 154 | // |
| 155 | // FIXME: tblgen this. |
| 156 | static const char *getARMTargetCPU(const ArgList &Args, |
| 157 | const llvm::Triple &Triple) { |
Bob Wilson | 677a35b | 2012-03-21 16:31:37 +0000 | [diff] [blame] | 158 | // For Darwin targets, the -arch option (which is translated to a |
| 159 | // corresponding -march option) should determine the architecture |
| 160 | // (and the Mach-O slice) regardless of any -mcpu options. |
| 161 | if (!Triple.isOSDarwin()) { |
| 162 | // FIXME: Warn on inconsistent use of -mcpu and -march. |
| 163 | // If we have -mcpu=, use that. |
| 164 | if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) |
Richard Smith | 1d489cf | 2012-11-01 04:30:05 +0000 | [diff] [blame] | 165 | return A->getValue(); |
Bob Wilson | 677a35b | 2012-03-21 16:31:37 +0000 | [diff] [blame] | 166 | } |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 167 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 168 | StringRef MArch; |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 169 | if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { |
| 170 | // Otherwise, if we have -march= choose the base CPU for that arch. |
Richard Smith | 1d489cf | 2012-11-01 04:30:05 +0000 | [diff] [blame] | 171 | MArch = A->getValue(); |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 172 | } else { |
| 173 | // Otherwise, use the Arch from the triple. |
| 174 | MArch = Triple.getArchName(); |
| 175 | } |
| 176 | |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 177 | return llvm::StringSwitch<const char *>(MArch) |
| 178 | .Cases("armv2", "armv2a","arm2") |
| 179 | .Case("armv3", "arm6") |
| 180 | .Case("armv3m", "arm7m") |
Tim Northover | 4889a1f | 2013-06-13 15:02:46 +0000 | [diff] [blame] | 181 | .Case("armv4", "strongarm") |
| 182 | .Case("armv4t", "arm7tdmi") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 183 | .Cases("armv5", "armv5t", "arm10tdmi") |
| 184 | .Cases("armv5e", "armv5te", "arm1026ejs") |
| 185 | .Case("armv5tej", "arm926ej-s") |
| 186 | .Cases("armv6", "armv6k", "arm1136jf-s") |
| 187 | .Case("armv6j", "arm1136j-s") |
| 188 | .Cases("armv6z", "armv6zk", "arm1176jzf-s") |
| 189 | .Case("armv6t2", "arm1156t2-s") |
Bob Wilson | 2503ebd | 2013-03-04 22:37:49 +0000 | [diff] [blame] | 190 | .Cases("armv6m", "armv6-m", "cortex-m0") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 191 | .Cases("armv7", "armv7a", "armv7-a", "cortex-a8") |
Renato Golin | 40a94e2 | 2013-02-05 23:42:01 +0000 | [diff] [blame] | 192 | .Cases("armv7l", "armv7-l", "cortex-a8") |
Bob Wilson | 336bfa3 | 2012-09-29 23:52:50 +0000 | [diff] [blame] | 193 | .Cases("armv7f", "armv7-f", "cortex-a9-mp") |
| 194 | .Cases("armv7s", "armv7-s", "swift") |
Bob Wilson | 532f5a9 | 2013-03-04 22:37:43 +0000 | [diff] [blame] | 195 | .Cases("armv7r", "armv7-r", "cortex-r4") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 196 | .Cases("armv7m", "armv7-m", "cortex-m3") |
Bob Wilson | 2503ebd | 2013-03-04 22:37:49 +0000 | [diff] [blame] | 197 | .Cases("armv7em", "armv7e-m", "cortex-m4") |
Joey Gouly | 4ec8d5b | 2013-06-26 17:19:48 +0000 | [diff] [blame^] | 198 | .Cases("armv8", "armv8a", "armv8-a", "cortex-a53") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 199 | .Case("ep9312", "ep9312") |
| 200 | .Case("iwmmxt", "iwmmxt") |
| 201 | .Case("xscale", "xscale") |
Tim Northover | 4889a1f | 2013-06-13 15:02:46 +0000 | [diff] [blame] | 202 | // If all else failed, return the most base CPU with thumb interworking |
| 203 | // supported by LLVM. |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 204 | .Default("arm7tdmi"); |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular |
| 208 | /// CPU. |
| 209 | // |
| 210 | // FIXME: This is redundant with -mcpu, why does LLVM use this. |
| 211 | // FIXME: tblgen this, or kill it! |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 212 | static const char *getLLVMArchSuffixForARM(StringRef CPU) { |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 213 | return llvm::StringSwitch<const char *>(CPU) |
Tim Northover | 4889a1f | 2013-06-13 15:02:46 +0000 | [diff] [blame] | 214 | .Case("strongarm", "v4") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 215 | .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t") |
| 216 | .Cases("arm720t", "arm9", "arm9tdmi", "v4t") |
| 217 | .Cases("arm920", "arm920t", "arm922t", "v4t") |
| 218 | .Cases("arm940t", "ep9312","v4t") |
| 219 | .Cases("arm10tdmi", "arm1020t", "v5") |
| 220 | .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e") |
| 221 | .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e") |
| 222 | .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e") |
| 223 | .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6") |
| 224 | .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6") |
| 225 | .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2") |
Bob Wilson | fc55345 | 2013-03-04 22:37:46 +0000 | [diff] [blame] | 226 | .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7") |
| 227 | .Cases("cortex-a9", "cortex-a15", "v7") |
| 228 | .Case("cortex-r5", "v7r") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 229 | .Case("cortex-m0", "v6m") |
Bob Wilson | 2503ebd | 2013-03-04 22:37:49 +0000 | [diff] [blame] | 230 | .Case("cortex-m3", "v7m") |
| 231 | .Case("cortex-m4", "v7em") |
Bob Wilson | 336bfa3 | 2012-09-29 23:52:50 +0000 | [diff] [blame] | 232 | .Case("cortex-a9-mp", "v7f") |
| 233 | .Case("swift", "v7s") |
Joey Gouly | 4ec8d5b | 2013-06-26 17:19:48 +0000 | [diff] [blame^] | 234 | .Case("cortex-a53", "v8") |
Bob Wilson | 57f6d19 | 2012-03-21 17:19:12 +0000 | [diff] [blame] | 235 | .Default(""); |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 236 | } |
| 237 | |
Chad Rosier | 61ab80a | 2011-09-20 20:44:06 +0000 | [diff] [blame] | 238 | std::string ToolChain::ComputeLLVMTriple(const ArgList &Args, |
| 239 | types::ID InputType) const { |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 240 | switch (getTriple().getArch()) { |
| 241 | default: |
| 242 | return getTripleString(); |
| 243 | |
| 244 | case llvm::Triple::arm: |
| 245 | case llvm::Triple::thumb: { |
| 246 | // FIXME: Factor into subclasses. |
| 247 | llvm::Triple Triple = getTriple(); |
| 248 | |
| 249 | // Thumb2 is the default for V7 on Darwin. |
| 250 | // |
| 251 | // FIXME: Thumb should just be another -target-feaure, not in the triple. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 252 | StringRef Suffix = |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 253 | getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); |
Bob Wilson | 2503ebd | 2013-03-04 22:37:49 +0000 | [diff] [blame] | 254 | bool ThumbDefault = Suffix.startswith("v6m") || |
| 255 | (Suffix.startswith("v7") && getTriple().isOSDarwin()); |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 256 | std::string ArchName = "arm"; |
Chad Rosier | 61ab80a | 2011-09-20 20:44:06 +0000 | [diff] [blame] | 257 | |
| 258 | // Assembly files should start in ARM mode. |
| 259 | if (InputType != types::TY_PP_Asm && |
| 260 | Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault)) |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 261 | ArchName = "thumb"; |
| 262 | Triple.setArchName(ArchName + Suffix.str()); |
| 263 | |
| 264 | return Triple.getTriple(); |
| 265 | } |
| 266 | } |
| 267 | } |
| 268 | |
Chad Rosier | 61ab80a | 2011-09-20 20:44:06 +0000 | [diff] [blame] | 269 | std::string ToolChain::ComputeEffectiveClangTriple(const ArgList &Args, |
| 270 | types::ID InputType) const { |
Daniel Dunbar | 9d609f2 | 2011-04-30 04:15:58 +0000 | [diff] [blame] | 271 | // Diagnose use of Darwin OS deployment target arguments on non-Darwin. |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 272 | if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ, |
Daniel Dunbar | 9d609f2 | 2011-04-30 04:15:58 +0000 | [diff] [blame] | 273 | options::OPT_miphoneos_version_min_EQ, |
| 274 | options::OPT_mios_simulator_version_min_EQ)) |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 275 | getDriver().Diag(diag::err_drv_clang_unsupported) |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 276 | << A->getAsString(Args); |
| 277 | |
Chad Rosier | 61ab80a | 2011-09-20 20:44:06 +0000 | [diff] [blame] | 278 | return ComputeLLVMTriple(Args, InputType); |
Daniel Dunbar | 00577ad | 2010-08-23 22:35:37 +0000 | [diff] [blame] | 279 | } |
| 280 | |
Chandler Carruth | 88491fc | 2011-11-04 07:12:53 +0000 | [diff] [blame] | 281 | void ToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, |
| 282 | ArgStringList &CC1Args) const { |
| 283 | // Each toolchain should provide the appropriate include flags. |
| 284 | } |
| 285 | |
Chandler Carruth | a6b2581 | 2012-11-21 23:40:23 +0000 | [diff] [blame] | 286 | void ToolChain::addClangTargetOptions(const ArgList &DriverArgs, |
| 287 | ArgStringList &CC1Args) const { |
Rafael Espindola | 8af669f | 2012-06-19 01:26:10 +0000 | [diff] [blame] | 288 | } |
| 289 | |
Daniel Dunbar | c24767c | 2011-12-07 23:03:15 +0000 | [diff] [blame] | 290 | ToolChain::RuntimeLibType ToolChain::GetRuntimeLibType( |
| 291 | const ArgList &Args) const |
| 292 | { |
| 293 | if (Arg *A = Args.getLastArg(options::OPT_rtlib_EQ)) { |
Richard Smith | 1d489cf | 2012-11-01 04:30:05 +0000 | [diff] [blame] | 294 | StringRef Value = A->getValue(); |
Daniel Dunbar | c24767c | 2011-12-07 23:03:15 +0000 | [diff] [blame] | 295 | if (Value == "compiler-rt") |
| 296 | return ToolChain::RLT_CompilerRT; |
| 297 | if (Value == "libgcc") |
| 298 | return ToolChain::RLT_Libgcc; |
| 299 | getDriver().Diag(diag::err_drv_invalid_rtlib_name) |
| 300 | << A->getAsString(Args); |
| 301 | } |
| 302 | |
| 303 | return GetDefaultRuntimeLibType(); |
| 304 | } |
| 305 | |
Daniel Dunbar | 641b98b | 2010-09-14 23:12:35 +0000 | [diff] [blame] | 306 | ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{ |
Daniel Dunbar | 3f16c95 | 2010-09-14 23:12:40 +0000 | [diff] [blame] | 307 | if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { |
Richard Smith | 1d489cf | 2012-11-01 04:30:05 +0000 | [diff] [blame] | 308 | StringRef Value = A->getValue(); |
Daniel Dunbar | 3f16c95 | 2010-09-14 23:12:40 +0000 | [diff] [blame] | 309 | if (Value == "libc++") |
| 310 | return ToolChain::CST_Libcxx; |
| 311 | if (Value == "libstdc++") |
| 312 | return ToolChain::CST_Libstdcxx; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 313 | getDriver().Diag(diag::err_drv_invalid_stdlib_name) |
Daniel Dunbar | 3f16c95 | 2010-09-14 23:12:40 +0000 | [diff] [blame] | 314 | << A->getAsString(Args); |
| 315 | } |
| 316 | |
Daniel Dunbar | 641b98b | 2010-09-14 23:12:35 +0000 | [diff] [blame] | 317 | return ToolChain::CST_Libstdcxx; |
| 318 | } |
| 319 | |
Chandler Carruth | 79cbbdc | 2011-12-17 23:10:01 +0000 | [diff] [blame] | 320 | /// \brief Utility function to add a system include directory to CC1 arguments. |
| 321 | /*static*/ void ToolChain::addSystemInclude(const ArgList &DriverArgs, |
| 322 | ArgStringList &CC1Args, |
| 323 | const Twine &Path) { |
| 324 | CC1Args.push_back("-internal-isystem"); |
| 325 | CC1Args.push_back(DriverArgs.MakeArgString(Path)); |
| 326 | } |
| 327 | |
| 328 | /// \brief Utility function to add a system include directory with extern "C" |
| 329 | /// semantics to CC1 arguments. |
| 330 | /// |
| 331 | /// Note that this should be used rarely, and only for directories that |
| 332 | /// historically and for legacy reasons are treated as having implicit extern |
| 333 | /// "C" semantics. These semantics are *ignored* by and large today, but its |
| 334 | /// important to preserve the preprocessor changes resulting from the |
| 335 | /// classification. |
| 336 | /*static*/ void ToolChain::addExternCSystemInclude(const ArgList &DriverArgs, |
| 337 | ArgStringList &CC1Args, |
| 338 | const Twine &Path) { |
| 339 | CC1Args.push_back("-internal-externc-isystem"); |
| 340 | CC1Args.push_back(DriverArgs.MakeArgString(Path)); |
| 341 | } |
| 342 | |
Simon Atanasyan | 8e8e95c | 2013-04-20 08:15:03 +0000 | [diff] [blame] | 343 | void ToolChain::addExternCSystemIncludeIfExists(const ArgList &DriverArgs, |
| 344 | ArgStringList &CC1Args, |
| 345 | const Twine &Path) { |
| 346 | if (llvm::sys::fs::exists(Path)) |
| 347 | addExternCSystemInclude(DriverArgs, CC1Args, Path); |
| 348 | } |
| 349 | |
Chandler Carruth | 79cbbdc | 2011-12-17 23:10:01 +0000 | [diff] [blame] | 350 | /// \brief Utility function to add a list of system include directories to CC1. |
| 351 | /*static*/ void ToolChain::addSystemIncludes(const ArgList &DriverArgs, |
| 352 | ArgStringList &CC1Args, |
| 353 | ArrayRef<StringRef> Paths) { |
| 354 | for (ArrayRef<StringRef>::iterator I = Paths.begin(), E = Paths.end(); |
| 355 | I != E; ++I) { |
| 356 | CC1Args.push_back("-internal-isystem"); |
| 357 | CC1Args.push_back(DriverArgs.MakeArgString(*I)); |
| 358 | } |
| 359 | } |
| 360 | |
Chandler Carruth | ab9fcd0 | 2011-11-04 23:49:01 +0000 | [diff] [blame] | 361 | void ToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, |
| 362 | ArgStringList &CC1Args) const { |
Chandler Carruth | a461442 | 2011-11-04 07:43:33 +0000 | [diff] [blame] | 363 | // Header search paths should be handled by each of the subclasses. |
| 364 | // Historically, they have not been, and instead have been handled inside of |
| 365 | // the CC1-layer frontend. As the logic is hoisted out, this generic function |
| 366 | // will slowly stop being called. |
| 367 | // |
| 368 | // While it is being called, replicate a bit of a hack to propagate the |
| 369 | // '-stdlib=' flag down to CC1 so that it can in turn customize the C++ |
| 370 | // header search paths with it. Once all systems are overriding this |
| 371 | // function, the CC1 flag and this line can be removed. |
Chandler Carruth | ab9fcd0 | 2011-11-04 23:49:01 +0000 | [diff] [blame] | 372 | DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ); |
Daniel Dunbar | 641b98b | 2010-09-14 23:12:35 +0000 | [diff] [blame] | 373 | } |
| 374 | |
Daniel Dunbar | 132e35d | 2010-09-17 01:20:05 +0000 | [diff] [blame] | 375 | void ToolChain::AddCXXStdlibLibArgs(const ArgList &Args, |
| 376 | ArgStringList &CmdArgs) const { |
Daniel Dunbar | 641b98b | 2010-09-14 23:12:35 +0000 | [diff] [blame] | 377 | CXXStdlibType Type = GetCXXStdlibType(Args); |
| 378 | |
| 379 | switch (Type) { |
Daniel Dunbar | 3f16c95 | 2010-09-14 23:12:40 +0000 | [diff] [blame] | 380 | case ToolChain::CST_Libcxx: |
| 381 | CmdArgs.push_back("-lc++"); |
| 382 | break; |
| 383 | |
Daniel Dunbar | 641b98b | 2010-09-14 23:12:35 +0000 | [diff] [blame] | 384 | case ToolChain::CST_Libstdcxx: |
| 385 | CmdArgs.push_back("-lstdc++"); |
| 386 | break; |
| 387 | } |
| 388 | } |
Shantonu Sen | 7433fed | 2010-09-17 18:39:08 +0000 | [diff] [blame] | 389 | |
| 390 | void ToolChain::AddCCKextLibArgs(const ArgList &Args, |
| 391 | ArgStringList &CmdArgs) const { |
| 392 | CmdArgs.push_back("-lcc_kext"); |
| 393 | } |
Benjamin Kramer | e20e508 | 2012-10-04 19:42:20 +0000 | [diff] [blame] | 394 | |
| 395 | bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args, |
| 396 | ArgStringList &CmdArgs) const { |
| 397 | // Check if -ffast-math or -funsafe-math is enabled. |
| 398 | Arg *A = Args.getLastArg(options::OPT_ffast_math, |
| 399 | options::OPT_fno_fast_math, |
| 400 | options::OPT_funsafe_math_optimizations, |
| 401 | options::OPT_fno_unsafe_math_optimizations); |
| 402 | |
| 403 | if (!A || A->getOption().getID() == options::OPT_fno_fast_math || |
| 404 | A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations) |
| 405 | return false; |
| 406 | |
| 407 | // If crtfastmath.o exists add it to the arguments. |
| 408 | std::string Path = GetFilePath("crtfastmath.o"); |
| 409 | if (Path == "crtfastmath.o") // Not found. |
| 410 | return false; |
| 411 | |
| 412 | CmdArgs.push_back(Args.MakeArgString(Path)); |
| 413 | return true; |
| 414 | } |