1 //===--- ToolChain.cpp - Collections of tools for one platform ------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "clang/Driver/ToolChain.h" 11 12 #include "clang/Driver/Action.h" 13 #include "clang/Driver/Arg.h" 14 #include "clang/Driver/ArgList.h" 15 #include "clang/Driver/Driver.h" 16 #include "clang/Driver/DriverDiagnostic.h" 17 #include "clang/Driver/HostInfo.h" 18 #include "clang/Driver/ObjCRuntime.h" 19 #include "clang/Driver/Options.h" 20 #include "llvm/Support/ErrorHandling.h" 21 22 using namespace clang::driver; 23 24 ToolChain::ToolChain(const HostInfo &_Host, const llvm::Triple &_Triple) 25 : Host(_Host), Triple(_Triple) { 26 } 27 28 ToolChain::~ToolChain() { 29 } 30 31 const Driver &ToolChain::getDriver() const { 32 return Host.getDriver(); 33 } 34 35 std::string ToolChain::GetFilePath(const char *Name) const { 36 return Host.getDriver().GetFilePath(Name, *this); 37 38 } 39 40 std::string ToolChain::GetProgramPath(const char *Name, bool WantFile) const { 41 return Host.getDriver().GetProgramPath(Name, *this, WantFile); 42 } 43 44 types::ID ToolChain::LookupTypeForExtension(const char *Ext) const { 45 return types::lookupTypeForExtension(Ext); 46 } 47 48 bool ToolChain::HasNativeLLVMSupport() const { 49 return false; 50 } 51 52 void ToolChain::configureObjCRuntime(ObjCRuntime &runtime) const { 53 switch (runtime.getKind()) { 54 case ObjCRuntime::NeXT: 55 // Assume a minimal NeXT runtime. 56 runtime.HasARC = false; 57 runtime.HasWeak = false; 58 runtime.HasTerminate = false; 59 return; 60 61 case ObjCRuntime::GNU: 62 // Assume a maximal GNU runtime. 63 runtime.HasARC = true; 64 runtime.HasWeak = true; 65 runtime.HasTerminate = false; // to be added 66 return; 67 } 68 llvm_unreachable("invalid runtime kind!"); 69 } 70 71 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting. 72 // 73 // FIXME: tblgen this. 74 static const char *getARMTargetCPU(const ArgList &Args, 75 const llvm::Triple &Triple) { 76 // FIXME: Warn on inconsistent use of -mcpu and -march. 77 78 // If we have -mcpu=, use that. 79 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 80 return A->getValue(Args); 81 82 llvm::StringRef MArch; 83 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 84 // Otherwise, if we have -march= choose the base CPU for that arch. 85 MArch = A->getValue(Args); 86 } else { 87 // Otherwise, use the Arch from the triple. 88 MArch = Triple.getArchName(); 89 } 90 91 if (MArch == "armv2" || MArch == "armv2a") 92 return "arm2"; 93 if (MArch == "armv3") 94 return "arm6"; 95 if (MArch == "armv3m") 96 return "arm7m"; 97 if (MArch == "armv4" || MArch == "armv4t") 98 return "arm7tdmi"; 99 if (MArch == "armv5" || MArch == "armv5t") 100 return "arm10tdmi"; 101 if (MArch == "armv5e" || MArch == "armv5te") 102 return "arm1026ejs"; 103 if (MArch == "armv5tej") 104 return "arm926ej-s"; 105 if (MArch == "armv6" || MArch == "armv6k") 106 return "arm1136jf-s"; 107 if (MArch == "armv6j") 108 return "arm1136j-s"; 109 if (MArch == "armv6z" || MArch == "armv6zk") 110 return "arm1176jzf-s"; 111 if (MArch == "armv6t2") 112 return "arm1156t2-s"; 113 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 114 return "cortex-a8"; 115 if (MArch == "armv7r" || MArch == "armv7-r") 116 return "cortex-r4"; 117 if (MArch == "armv7m" || MArch == "armv7-m") 118 return "cortex-m3"; 119 if (MArch == "ep9312") 120 return "ep9312"; 121 if (MArch == "iwmmxt") 122 return "iwmmxt"; 123 if (MArch == "xscale") 124 return "xscale"; 125 if (MArch == "armv6m" || MArch == "armv6-m") 126 return "cortex-m0"; 127 128 // If all else failed, return the most base CPU LLVM supports. 129 return "arm7tdmi"; 130 } 131 132 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 133 /// CPU. 134 // 135 // FIXME: This is redundant with -mcpu, why does LLVM use this. 136 // FIXME: tblgen this, or kill it! 137 static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) { 138 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" || 139 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" || 140 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" || 141 CPU == "arm940t" || CPU == "ep9312") 142 return "v4t"; 143 144 if (CPU == "arm10tdmi" || CPU == "arm1020t") 145 return "v5"; 146 147 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" || 148 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" || 149 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" || 150 CPU == "iwmmxt") 151 return "v5e"; 152 153 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" || 154 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore") 155 return "v6"; 156 157 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s") 158 return "v6t2"; 159 160 if (CPU == "cortex-a8" || CPU == "cortex-a9") 161 return "v7"; 162 163 if (CPU == "cortex-m3") 164 return "v7m"; 165 166 if (CPU == "cortex-m0") 167 return "v6m"; 168 169 return ""; 170 } 171 172 std::string ToolChain::ComputeLLVMTriple(const ArgList &Args) const { 173 switch (getTriple().getArch()) { 174 default: 175 return getTripleString(); 176 177 case llvm::Triple::arm: 178 case llvm::Triple::thumb: { 179 // FIXME: Factor into subclasses. 180 llvm::Triple Triple = getTriple(); 181 182 // Thumb2 is the default for V7 on Darwin. 183 // 184 // FIXME: Thumb should just be another -target-feaure, not in the triple. 185 llvm::StringRef Suffix = 186 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 187 bool ThumbDefault = 188 (Suffix == "v7" && getTriple().getOS() == llvm::Triple::Darwin); 189 std::string ArchName = "arm"; 190 if (Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault)) 191 ArchName = "thumb"; 192 Triple.setArchName(ArchName + Suffix.str()); 193 194 return Triple.getTriple(); 195 } 196 } 197 } 198 199 std::string ToolChain::ComputeEffectiveClangTriple(const ArgList &Args) const { 200 // Diagnose use of Darwin OS deployment target arguments on non-Darwin. 201 if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ, 202 options::OPT_miphoneos_version_min_EQ, 203 options::OPT_mios_simulator_version_min_EQ)) 204 getDriver().Diag(clang::diag::err_drv_clang_unsupported) 205 << A->getAsString(Args); 206 207 return ComputeLLVMTriple(Args); 208 } 209 210 ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{ 211 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { 212 llvm::StringRef Value = A->getValue(Args); 213 if (Value == "libc++") 214 return ToolChain::CST_Libcxx; 215 if (Value == "libstdc++") 216 return ToolChain::CST_Libstdcxx; 217 getDriver().Diag(clang::diag::err_drv_invalid_stdlib_name) 218 << A->getAsString(Args); 219 } 220 221 return ToolChain::CST_Libstdcxx; 222 } 223 224 void ToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &Args, 225 ArgStringList &CmdArgs, 226 bool ObjCXXAutoRefCount) const { 227 CXXStdlibType Type = GetCXXStdlibType(Args); 228 229 // Header search paths are handled by the mass of goop in InitHeaderSearch. 230 231 switch (Type) { 232 case ToolChain::CST_Libcxx: 233 if (ObjCXXAutoRefCount) 234 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++"); 235 break; 236 237 case ToolChain::CST_Libstdcxx: 238 if (ObjCXXAutoRefCount) 239 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++"); 240 break; 241 } 242 } 243 244 void ToolChain::AddCXXStdlibLibArgs(const ArgList &Args, 245 ArgStringList &CmdArgs) const { 246 CXXStdlibType Type = GetCXXStdlibType(Args); 247 248 switch (Type) { 249 case ToolChain::CST_Libcxx: 250 CmdArgs.push_back("-lc++"); 251 break; 252 253 case ToolChain::CST_Libstdcxx: 254 CmdArgs.push_back("-lstdc++"); 255 break; 256 } 257 } 258 259 void ToolChain::AddCCKextLibArgs(const ArgList &Args, 260 ArgStringList &CmdArgs) const { 261 CmdArgs.push_back("-lcc_kext"); 262 } 263
