1 //===--- X86.cpp - X86 Helpers for Tools ------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "X86.h" 10 #include "ToolChains/CommonArgs.h" 11 #include "clang/Driver/Driver.h" 12 #include "clang/Driver/DriverDiagnostic.h" 13 #include "clang/Driver/Options.h" 14 #include "llvm/ADT/StringExtras.h" 15 #include "llvm/ADT/StringMap.h" 16 #include "llvm/Option/ArgList.h" 17 #include "llvm/TargetParser/Host.h" 18 19 using namespace clang::driver; 20 using namespace clang::driver::tools; 21 using namespace clang; 22 using namespace llvm::opt; 23 24 std::string x86::getX86TargetCPU(const Driver &D, const ArgList &Args, 25 const llvm::Triple &Triple) { 26 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ)) { 27 StringRef CPU = A->getValue(); 28 if (CPU != "native") 29 return std::string(CPU); 30 31 // FIXME: Reject attempts to use -march=native unless the target matches 32 // the host. 33 CPU = llvm::sys::getHostCPUName(); 34 if (!CPU.empty() && CPU != "generic") 35 return std::string(CPU); 36 } 37 38 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) { 39 // Mapping built by looking at lib/Basic's X86TargetInfo::initFeatureMap(). 40 // The keys are case-sensitive; this matches link.exe. 41 // 32-bit and 64-bit /arch: flags. 42 llvm::StringMap<StringRef> ArchMap({ 43 {"AVX", "sandybridge"}, 44 {"AVX2", "haswell"}, 45 {"AVX512F", "knl"}, 46 {"AVX512", "skylake-avx512"}, 47 }); 48 if (Triple.getArch() == llvm::Triple::x86) { 49 // 32-bit-only /arch: flags. 50 ArchMap.insert({ 51 {"IA32", "i386"}, 52 {"SSE", "pentium3"}, 53 {"SSE2", "pentium4"}, 54 }); 55 } 56 StringRef CPU = ArchMap.lookup(A->getValue()); 57 if (CPU.empty()) { 58 std::vector<StringRef> ValidArchs{ArchMap.keys().begin(), 59 ArchMap.keys().end()}; 60 sort(ValidArchs); 61 D.Diag(diag::warn_drv_invalid_arch_name_with_suggestion) 62 << A->getValue() << (Triple.getArch() == llvm::Triple::x86) 63 << join(ValidArchs, ", "); 64 } 65 return std::string(CPU); 66 } 67 68 // Select the default CPU if none was given (or detection failed). 69 70 if (!Triple.isX86()) 71 return ""; // This routine is only handling x86 targets. 72 73 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64; 74 75 // FIXME: Need target hooks. 76 if (Triple.isOSDarwin()) { 77 if (Triple.getArchName() == "x86_64h") 78 return "core-avx2"; 79 // macosx10.12 drops support for all pre-Penryn Macs. 80 // Simulators can still run on 10.11 though, like Xcode. 81 if (Triple.isMacOSX() && !Triple.isOSVersionLT(10, 12)) 82 return "penryn"; 83 84 if (Triple.isDriverKit()) 85 return "nehalem"; 86 87 // The oldest x86_64 Macs have core2/Merom; the oldest x86 Macs have Yonah. 88 return Is64Bit ? "core2" : "yonah"; 89 } 90 91 // Set up default CPU name for PS4/PS5 compilers. 92 if (Triple.isPS4()) 93 return "btver2"; 94 if (Triple.isPS5()) 95 return "znver2"; 96 97 // On Android use targets compatible with gcc 98 if (Triple.isAndroid()) 99 return Is64Bit ? "x86-64" : "i686"; 100 101 // Everything else goes to x86-64 in 64-bit mode. 102 if (Is64Bit) 103 return "x86-64"; 104 105 switch (Triple.getOS()) { 106 case llvm::Triple::NetBSD: 107 return "i486"; 108 case llvm::Triple::Haiku: 109 case llvm::Triple::OpenBSD: 110 return "i586"; 111 case llvm::Triple::FreeBSD: 112 return "i686"; 113 default: 114 // Fallback to p4. 115 return "pentium4"; 116 } 117 } 118 119 void x86::getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple, 120 const ArgList &Args, 121 std::vector<StringRef> &Features) { 122 // Claim and report unsupported -mabi=. Note: we don't support "sysv_abi" or 123 // "ms_abi" as default function attributes. 124 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mabi_EQ)) { 125 StringRef DefaultAbi = Triple.isOSWindows() ? "ms" : "sysv"; 126 if (A->getValue() != DefaultAbi) 127 D.Diag(diag::err_drv_unsupported_opt_for_target) 128 << A->getSpelling() << Triple.getTriple(); 129 } 130 131 // If -march=native, autodetect the feature list. 132 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ)) { 133 if (StringRef(A->getValue()) == "native") { 134 llvm::StringMap<bool> HostFeatures; 135 if (llvm::sys::getHostCPUFeatures(HostFeatures)) 136 for (auto &F : HostFeatures) 137 Features.push_back( 138 Args.MakeArgString((F.second ? "+" : "-") + F.first())); 139 } 140 } 141 142 if (Triple.getArchName() == "x86_64h") { 143 // x86_64h implies quite a few of the more modern subtarget features 144 // for Haswell class CPUs, but not all of them. Opt-out of a few. 145 Features.push_back("-rdrnd"); 146 Features.push_back("-aes"); 147 Features.push_back("-pclmul"); 148 Features.push_back("-rtm"); 149 Features.push_back("-fsgsbase"); 150 } 151 152 const llvm::Triple::ArchType ArchType = Triple.getArch(); 153 // Add features to be compatible with gcc for Android. 154 if (Triple.isAndroid()) { 155 if (ArchType == llvm::Triple::x86_64) { 156 Features.push_back("+sse4.2"); 157 Features.push_back("+popcnt"); 158 Features.push_back("+cx16"); 159 } else 160 Features.push_back("+ssse3"); 161 } 162 163 // Translate the high level `-mretpoline` flag to the specific target feature 164 // flags. We also detect if the user asked for retpoline external thunks but 165 // failed to ask for retpolines themselves (through any of the different 166 // flags). This is a bit hacky but keeps existing usages working. We should 167 // consider deprecating this and instead warn if the user requests external 168 // retpoline thunks and *doesn't* request some form of retpolines. 169 auto SpectreOpt = clang::driver::options::ID::OPT_INVALID; 170 if (Args.hasArgNoClaim(options::OPT_mretpoline, options::OPT_mno_retpoline, 171 options::OPT_mspeculative_load_hardening, 172 options::OPT_mno_speculative_load_hardening)) { 173 if (Args.hasFlag(options::OPT_mretpoline, options::OPT_mno_retpoline, 174 false)) { 175 Features.push_back("+retpoline-indirect-calls"); 176 Features.push_back("+retpoline-indirect-branches"); 177 SpectreOpt = options::OPT_mretpoline; 178 } else if (Args.hasFlag(options::OPT_mspeculative_load_hardening, 179 options::OPT_mno_speculative_load_hardening, 180 false)) { 181 // On x86, speculative load hardening relies on at least using retpolines 182 // for indirect calls. 183 Features.push_back("+retpoline-indirect-calls"); 184 SpectreOpt = options::OPT_mspeculative_load_hardening; 185 } 186 } else if (Args.hasFlag(options::OPT_mretpoline_external_thunk, 187 options::OPT_mno_retpoline_external_thunk, false)) { 188 // FIXME: Add a warning about failing to specify `-mretpoline` and 189 // eventually switch to an error here. 190 Features.push_back("+retpoline-indirect-calls"); 191 Features.push_back("+retpoline-indirect-branches"); 192 SpectreOpt = options::OPT_mretpoline_external_thunk; 193 } 194 195 auto LVIOpt = clang::driver::options::ID::OPT_INVALID; 196 if (Args.hasFlag(options::OPT_mlvi_hardening, options::OPT_mno_lvi_hardening, 197 false)) { 198 Features.push_back("+lvi-load-hardening"); 199 Features.push_back("+lvi-cfi"); // load hardening implies CFI protection 200 LVIOpt = options::OPT_mlvi_hardening; 201 } else if (Args.hasFlag(options::OPT_mlvi_cfi, options::OPT_mno_lvi_cfi, 202 false)) { 203 Features.push_back("+lvi-cfi"); 204 LVIOpt = options::OPT_mlvi_cfi; 205 } 206 207 if (Args.hasFlag(options::OPT_m_seses, options::OPT_mno_seses, false)) { 208 if (LVIOpt == options::OPT_mlvi_hardening) 209 D.Diag(diag::err_drv_argument_not_allowed_with) 210 << D.getOpts().getOptionName(options::OPT_mlvi_hardening) 211 << D.getOpts().getOptionName(options::OPT_m_seses); 212 213 if (SpectreOpt != clang::driver::options::ID::OPT_INVALID) 214 D.Diag(diag::err_drv_argument_not_allowed_with) 215 << D.getOpts().getOptionName(SpectreOpt) 216 << D.getOpts().getOptionName(options::OPT_m_seses); 217 218 Features.push_back("+seses"); 219 if (!Args.hasArg(options::OPT_mno_lvi_cfi)) { 220 Features.push_back("+lvi-cfi"); 221 LVIOpt = options::OPT_mlvi_cfi; 222 } 223 } 224 225 if (SpectreOpt != clang::driver::options::ID::OPT_INVALID && 226 LVIOpt != clang::driver::options::ID::OPT_INVALID) { 227 D.Diag(diag::err_drv_argument_not_allowed_with) 228 << D.getOpts().getOptionName(SpectreOpt) 229 << D.getOpts().getOptionName(LVIOpt); 230 } 231 232 // Now add any that the user explicitly requested on the command line, 233 // which may override the defaults. 234 for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group, 235 options::OPT_mgeneral_regs_only)) { 236 StringRef Name = A->getOption().getName(); 237 A->claim(); 238 239 // Skip over "-m". 240 assert(Name.startswith("m") && "Invalid feature name."); 241 Name = Name.substr(1); 242 243 // Replace -mgeneral-regs-only with -x87, -mmx, -sse 244 if (A->getOption().getID() == options::OPT_mgeneral_regs_only) { 245 Features.insert(Features.end(), {"-x87", "-mmx", "-sse"}); 246 continue; 247 } 248 249 bool IsNegative = Name.startswith("no-"); 250 if (IsNegative) 251 Name = Name.substr(3); 252 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 253 } 254 255 // Enable/disable straight line speculation hardening. 256 if (Arg *A = Args.getLastArg(options::OPT_mharden_sls_EQ)) { 257 StringRef Scope = A->getValue(); 258 if (Scope == "all") { 259 Features.push_back("+harden-sls-ijmp"); 260 Features.push_back("+harden-sls-ret"); 261 } else if (Scope == "return") { 262 Features.push_back("+harden-sls-ret"); 263 } else if (Scope == "indirect-jmp") { 264 Features.push_back("+harden-sls-ijmp"); 265 } else if (Scope != "none") { 266 D.Diag(diag::err_drv_unsupported_option_argument) 267 << A->getSpelling() << Scope; 268 } 269 } 270 271 // -mno-gather, -mno-scatter support 272 if (Args.hasArg(options::OPT_mno_gather)) 273 Features.push_back("+prefer-no-gather"); 274 if (Args.hasArg(options::OPT_mno_scatter)) 275 Features.push_back("+prefer-no-scatter"); 276 } 277