X86.cpp revision 363496 
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/StringSwitch.h"
15#include "llvm/Option/ArgList.h"
16#include "llvm/Support/Host.h"
17
18using namespace clang::driver;
19using namespace clang::driver::tools;
20using namespace clang;
21using namespace llvm::opt;
22
23const char *x86::getX86TargetCPU(const ArgList &Args,
24                                 const llvm::Triple &Triple) {
25  if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ)) {
26    if (StringRef(A->getValue()) != "native")
27      return A->getValue();
28
29    // FIXME: Reject attempts to use -march=native unless the target matches
30    // the host.
31    //
32    // FIXME: We should also incorporate the detected target features for use
33    // with -native.
34    std::string CPU = llvm::sys::getHostCPUName();
35    if (!CPU.empty() && CPU != "generic")
36      return Args.MakeArgString(CPU);
37  }
38
39  if (const Arg *A = Args.getLastArgNoClaim(options::OPT__SLASH_arch)) {
40    // Mapping built by looking at lib/Basic's X86TargetInfo::initFeatureMap().
41    StringRef Arch = A->getValue();
42    const char *CPU = nullptr;
43    if (Triple.getArch() == llvm::Triple::x86) {  // 32-bit-only /arch: flags.
44      CPU = llvm::StringSwitch<const char *>(Arch)
45                .Case("IA32", "i386")
46                .Case("SSE", "pentium3")
47                .Case("SSE2", "pentium4")
48                .Default(nullptr);
49    }
50    if (CPU == nullptr) {  // 32-bit and 64-bit /arch: flags.
51      CPU = llvm::StringSwitch<const char *>(Arch)
52                .Case("AVX", "sandybridge")
53                .Case("AVX2", "haswell")
54                .Case("AVX512F", "knl")
55                .Case("AVX512", "skylake-avx512")
56                .Default(nullptr);
57    }
58    if (CPU) {
59      A->claim();
60      return CPU;
61    }
62  }
63
64  // Select the default CPU if none was given (or detection failed).
65
66  if (!Triple.isX86())
67    return nullptr; // This routine is only handling x86 targets.
68
69  bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
70
71  // FIXME: Need target hooks.
72  if (Triple.isOSDarwin()) {
73    if (Triple.getArchName() == "x86_64h")
74      return "core-avx2";
75    // macosx10.12 drops support for all pre-Penryn Macs.
76    // Simulators can still run on 10.11 though, like Xcode.
77    if (Triple.isMacOSX() && !Triple.isOSVersionLT(10, 12))
78      return "penryn";
79    // The oldest x86_64 Macs have core2/Merom; the oldest x86 Macs have Yonah.
80    return Is64Bit ? "core2" : "yonah";
81  }
82
83  // Set up default CPU name for PS4 compilers.
84  if (Triple.isPS4CPU())
85    return "btver2";
86
87  // On Android use targets compatible with gcc
88  if (Triple.isAndroid())
89    return Is64Bit ? "x86-64" : "i686";
90
91  // Everything else goes to x86-64 in 64-bit mode.
92  if (Is64Bit)
93    return "x86-64";
94
95  switch (Triple.getOS()) {
96  case llvm::Triple::FreeBSD:
97    return "i686";
98  case llvm::Triple::NetBSD:
99  case llvm::Triple::OpenBSD:
100    return "i486";
101  case llvm::Triple::Haiku:
102    return "i586";
103  default:
104    // Fallback to p4.
105    return "pentium4";
106  }
107}
108
109void x86::getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
110                               const ArgList &Args,
111                               std::vector<StringRef> &Features) {
112  // If -march=native, autodetect the feature list.
113  if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ)) {
114    if (StringRef(A->getValue()) == "native") {
115      llvm::StringMap<bool> HostFeatures;
116      if (llvm::sys::getHostCPUFeatures(HostFeatures))
117        for (auto &F : HostFeatures)
118          Features.push_back(
119              Args.MakeArgString((F.second ? "+" : "-") + F.first()));
120    }
121  }
122
123  if (Triple.getArchName() == "x86_64h") {
124    // x86_64h implies quite a few of the more modern subtarget features
125    // for Haswell class CPUs, but not all of them. Opt-out of a few.
126    Features.push_back("-rdrnd");
127    Features.push_back("-aes");
128    Features.push_back("-pclmul");
129    Features.push_back("-rtm");
130    Features.push_back("-fsgsbase");
131  }
132
133  const llvm::Triple::ArchType ArchType = Triple.getArch();
134  // Add features to be compatible with gcc for Android.
135  if (Triple.isAndroid()) {
136    if (ArchType == llvm::Triple::x86_64) {
137      Features.push_back("+sse4.2");
138      Features.push_back("+popcnt");
139      Features.push_back("+cx16");
140    } else
141      Features.push_back("+ssse3");
142  }
143
144  // Translate the high level `-mretpoline` flag to the specific target feature
145  // flags. We also detect if the user asked for retpoline external thunks but
146  // failed to ask for retpolines themselves (through any of the different
147  // flags). This is a bit hacky but keeps existing usages working. We should
148  // consider deprecating this and instead warn if the user requests external
149  // retpoline thunks and *doesn't* request some form of retpolines.
150  auto SpectreOpt = clang::driver::options::ID::OPT_INVALID;
151  if (Args.hasArgNoClaim(options::OPT_mretpoline, options::OPT_mno_retpoline,
152                         options::OPT_mspeculative_load_hardening,
153                         options::OPT_mno_speculative_load_hardening)) {
154    if (Args.hasFlag(options::OPT_mretpoline, options::OPT_mno_retpoline,
155                     false)) {
156      Features.push_back("+retpoline-indirect-calls");
157      Features.push_back("+retpoline-indirect-branches");
158      SpectreOpt = options::OPT_mretpoline;
159    } else if (Args.hasFlag(options::OPT_mspeculative_load_hardening,
160                            options::OPT_mno_speculative_load_hardening,
161                            false)) {
162      // On x86, speculative load hardening relies on at least using retpolines
163      // for indirect calls.
164      Features.push_back("+retpoline-indirect-calls");
165      SpectreOpt = options::OPT_mspeculative_load_hardening;
166    }
167  } else if (Args.hasFlag(options::OPT_mretpoline_external_thunk,
168                          options::OPT_mno_retpoline_external_thunk, false)) {
169    // FIXME: Add a warning about failing to specify `-mretpoline` and
170    // eventually switch to an error here.
171    Features.push_back("+retpoline-indirect-calls");
172    Features.push_back("+retpoline-indirect-branches");
173    SpectreOpt = options::OPT_mretpoline_external_thunk;
174  }
175
176  auto LVIOpt = clang::driver::options::ID::OPT_INVALID;
177  if (Args.hasFlag(options::OPT_mlvi_hardening, options::OPT_mno_lvi_hardening,
178                   false)) {
179    Features.push_back("+lvi-load-hardening");
180    Features.push_back("+lvi-cfi"); // load hardening implies CFI protection
181    LVIOpt = options::OPT_mlvi_hardening;
182  } else if (Args.hasFlag(options::OPT_mlvi_cfi, options::OPT_mno_lvi_cfi,
183                          false)) {
184    Features.push_back("+lvi-cfi");
185    LVIOpt = options::OPT_mlvi_cfi;
186  }
187
188  if (SpectreOpt != clang::driver::options::ID::OPT_INVALID &&
189      LVIOpt != clang::driver::options::ID::OPT_INVALID) {
190    D.Diag(diag::err_drv_argument_not_allowed_with)
191        << D.getOpts().getOptionName(SpectreOpt)
192        << D.getOpts().getOptionName(LVIOpt);
193  }
194
195  // Now add any that the user explicitly requested on the command line,
196  // which may override the defaults.
197  handleTargetFeaturesGroup(Args, Features, options::OPT_m_x86_Features_Group);
198}
199