Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 75e74e077c9fed24c00fb5e12078df2b192841da / . / clang / lib / Basic / Targets / PPC.cpp
blob: 14a9ffd09a6aecafbd9c1cbb00039a3209ba4abd [file] [log] [blame]
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]1//===--- PPC.cpp - Implement PPC target feature support -------------------===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +0000[diff] [blame]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
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements PPC TargetInfo objects.
10//
11//===----------------------------------------------------------------------===//
12
13#include "PPC.h"
14#include "clang/Basic/Diagnostic.h"
15#include "clang/Basic/MacroBuilder.h"
16#include "clang/Basic/TargetBuiltins.h"
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]17
18using namespace clang;
19using namespace clang::targets;
20
21const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
22#define BUILTIN(ID, TYPE, ATTRS) \
23 {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
24#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
25 {#ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr},
26#include "clang/Basic/BuiltinsPPC.def"
27};
28
29/// handleTargetFeatures - Perform initialization based on the user
30/// configured set of features.
31bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
32 DiagnosticsEngine &Diags) {
33 for (const auto &Feature : Features) {
34 if (Feature == "+altivec") {
35 HasAltivec = true;
36 } else if (Feature == "+vsx") {
37 HasVSX = true;
38 } else if (Feature == "+bpermd") {
39 HasBPERMD = true;
40 } else if (Feature == "+extdiv") {
41 HasExtDiv = true;
42 } else if (Feature == "+power8-vector") {
43 HasP8Vector = true;
44 } else if (Feature == "+crypto") {
45 HasP8Crypto = true;
46 } else if (Feature == "+direct-move") {
47 HasDirectMove = true;
48 } else if (Feature == "+qpx") {
49 HasQPX = true;
50 } else if (Feature == "+htm") {
51 HasHTM = true;
52 } else if (Feature == "+float128") {
53 HasFloat128 = true;
54 } else if (Feature == "+power9-vector") {
55 HasP9Vector = true;
56 }
57 // TODO: Finish this list and add an assert that we've handled them
58 // all.
59 }
60
61 return true;
62}
63
64/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
65/// #defines that are not tied to a specific subtarget.
66void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
67 MacroBuilder &Builder) const {
68 // Target identification.
69 Builder.defineMacro("__ppc__");
70 Builder.defineMacro("__PPC__");
71 Builder.defineMacro("_ARCH_PPC");
72 Builder.defineMacro("__powerpc__");
73 Builder.defineMacro("__POWERPC__");
74 if (PointerWidth == 64) {
75 Builder.defineMacro("_ARCH_PPC64");
76 Builder.defineMacro("__powerpc64__");
77 Builder.defineMacro("__ppc64__");
78 Builder.defineMacro("__PPC64__");
79 }
80
81 // Target properties.
82 if (getTriple().getArch() == llvm::Triple::ppc64le) {
83 Builder.defineMacro("_LITTLE_ENDIAN");
84 } else {
Michal Gorny5a409d02018-12-20 13:09:30 +0000[diff] [blame]85 if (!getTriple().isOSNetBSD() &&
86 !getTriple().isOSOpenBSD())
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]87 Builder.defineMacro("_BIG_ENDIAN");
88 }
89
90 // ABI options.
91 if (ABI == "elfv1" || ABI == "elfv1-qpx")
92 Builder.defineMacro("_CALL_ELF", "1");
93 if (ABI == "elfv2")
94 Builder.defineMacro("_CALL_ELF", "2");
95
96 // This typically is only for a new enough linker (bfd >= 2.16.2 or gold), but
Alexander Kornienko2a8c18d2018-04-06 15:14:32 +0000[diff] [blame]97 // our support post-dates this and it should work on all 64-bit ppc linux
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]98 // platforms. It is guaranteed to work on all elfv2 platforms.
99 if (getTriple().getOS() == llvm::Triple::Linux && PointerWidth == 64)
100 Builder.defineMacro("_CALL_LINUX", "1");
101
102 // Subtarget options.
Jason Liu7f7867b2019-03-14 21:54:30 +0000[diff] [blame]103 if (!getTriple().isOSAIX()){
104 Builder.defineMacro("__NATURAL_ALIGNMENT__");
105 }
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]106 Builder.defineMacro("__REGISTER_PREFIX__", "");
107
108 // FIXME: Should be controlled by command line option.
109 if (LongDoubleWidth == 128) {
110 Builder.defineMacro("__LONG_DOUBLE_128__");
111 Builder.defineMacro("__LONGDOUBLE128");
112 }
113
114 // Define this for elfv2 (64-bit only) or 64-bit darwin.
115 if (ABI == "elfv2" ||
116 (getTriple().getOS() == llvm::Triple::Darwin && PointerWidth == 64))
117 Builder.defineMacro("__STRUCT_PARM_ALIGN__", "16");
118
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]119 if (ArchDefs & ArchDefineName)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]120 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]121 if (ArchDefs & ArchDefinePpcgr)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]122 Builder.defineMacro("_ARCH_PPCGR");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]123 if (ArchDefs & ArchDefinePpcsq)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]124 Builder.defineMacro("_ARCH_PPCSQ");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]125 if (ArchDefs & ArchDefine440)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]126 Builder.defineMacro("_ARCH_440");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]127 if (ArchDefs & ArchDefine603)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]128 Builder.defineMacro("_ARCH_603");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]129 if (ArchDefs & ArchDefine604)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]130 Builder.defineMacro("_ARCH_604");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]131 if (ArchDefs & ArchDefinePwr4)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]132 Builder.defineMacro("_ARCH_PWR4");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]133 if (ArchDefs & ArchDefinePwr5)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]134 Builder.defineMacro("_ARCH_PWR5");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]135 if (ArchDefs & ArchDefinePwr5x)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]136 Builder.defineMacro("_ARCH_PWR5X");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]137 if (ArchDefs & ArchDefinePwr6)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]138 Builder.defineMacro("_ARCH_PWR6");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]139 if (ArchDefs & ArchDefinePwr6x)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]140 Builder.defineMacro("_ARCH_PWR6X");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]141 if (ArchDefs & ArchDefinePwr7)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]142 Builder.defineMacro("_ARCH_PWR7");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]143 if (ArchDefs & ArchDefinePwr8)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]144 Builder.defineMacro("_ARCH_PWR8");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]145 if (ArchDefs & ArchDefinePwr9)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]146 Builder.defineMacro("_ARCH_PWR9");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]147 if (ArchDefs & ArchDefineA2)
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]148 Builder.defineMacro("_ARCH_A2");
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]149 if (ArchDefs & ArchDefineA2q) {
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]150 Builder.defineMacro("_ARCH_A2Q");
151 Builder.defineMacro("_ARCH_QP");
152 }
153
154 if (getTriple().getVendor() == llvm::Triple::BGQ) {
155 Builder.defineMacro("__bg__");
156 Builder.defineMacro("__THW_BLUEGENE__");
157 Builder.defineMacro("__bgq__");
158 Builder.defineMacro("__TOS_BGQ__");
159 }
160
161 if (HasAltivec) {
162 Builder.defineMacro("__VEC__", "10206");
163 Builder.defineMacro("__ALTIVEC__");
164 }
165 if (HasVSX)
166 Builder.defineMacro("__VSX__");
167 if (HasP8Vector)
168 Builder.defineMacro("__POWER8_VECTOR__");
169 if (HasP8Crypto)
170 Builder.defineMacro("__CRYPTO__");
171 if (HasHTM)
172 Builder.defineMacro("__HTM__");
173 if (HasFloat128)
174 Builder.defineMacro("__FLOAT128__");
175 if (HasP9Vector)
176 Builder.defineMacro("__POWER9_VECTOR__");
177
178 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
179 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
180 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
181 if (PointerWidth == 64)
182 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
183
184 // We have support for the bswap intrinsics so we can define this.
185 Builder.defineMacro("__HAVE_BSWAP__", "1");
186
187 // FIXME: The following are not yet generated here by Clang, but are
188 // generated by GCC:
189 //
190 // _SOFT_FLOAT_
191 // __RECIP_PRECISION__
192 // __APPLE_ALTIVEC__
193 // __RECIP__
194 // __RECIPF__
195 // __RSQRTE__
196 // __RSQRTEF__
197 // _SOFT_DOUBLE_
198 // __NO_LWSYNC__
199 // __CMODEL_MEDIUM__
200 // __CMODEL_LARGE__
201 // _CALL_SYSV
202 // _CALL_DARWIN
203 // __NO_FPRS__
204}
205
206// Handle explicit options being passed to the compiler here: if we've
207// explicitly turned off vsx and turned on any of:
208// - power8-vector
209// - direct-move
210// - float128
211// - power9-vector
212// then go ahead and error since the customer has expressed an incompatible
213// set of options.
214static bool ppcUserFeaturesCheck(DiagnosticsEngine &Diags,
215 const std::vector<std::string> &FeaturesVec) {
216
Fangrui Song75e74e02019-03-31 08:48:19 +0000[diff] [blame^]217 if (llvm::find(FeaturesVec, "-vsx") != FeaturesVec.end()) {
218 if (llvm::find(FeaturesVec, "+power8-vector") != FeaturesVec.end()) {
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]219 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower8-vector"
220 << "-mno-vsx";
221 return false;
222 }
223
Fangrui Song75e74e02019-03-31 08:48:19 +0000[diff] [blame^]224 if (llvm::find(FeaturesVec, "+direct-move") != FeaturesVec.end()) {
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]225 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mdirect-move"
226 << "-mno-vsx";
227 return false;
228 }
229
Fangrui Song75e74e02019-03-31 08:48:19 +0000[diff] [blame^]230 if (llvm::find(FeaturesVec, "+float128") != FeaturesVec.end()) {
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]231 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfloat128"
232 << "-mno-vsx";
233 return false;
234 }
235
Fangrui Song75e74e02019-03-31 08:48:19 +0000[diff] [blame^]236 if (llvm::find(FeaturesVec, "+power9-vector") != FeaturesVec.end()) {
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]237 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower9-vector"
238 << "-mno-vsx";
239 return false;
240 }
241 }
242
243 return true;
244}
245
246bool PPCTargetInfo::initFeatureMap(
247 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
248 const std::vector<std::string> &FeaturesVec) const {
249 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
250 .Case("7400", true)
251 .Case("g4", true)
252 .Case("7450", true)
253 .Case("g4+", true)
254 .Case("970", true)
255 .Case("g5", true)
256 .Case("pwr6", true)
257 .Case("pwr7", true)
258 .Case("pwr8", true)
259 .Case("pwr9", true)
260 .Case("ppc64", true)
261 .Case("ppc64le", true)
262 .Default(false);
263
264 Features["qpx"] = (CPU == "a2q");
265 Features["power9-vector"] = (CPU == "pwr9");
266 Features["crypto"] = llvm::StringSwitch<bool>(CPU)
267 .Case("ppc64le", true)
268 .Case("pwr9", true)
269 .Case("pwr8", true)
270 .Default(false);
271 Features["power8-vector"] = llvm::StringSwitch<bool>(CPU)
272 .Case("ppc64le", true)
273 .Case("pwr9", true)
274 .Case("pwr8", true)
275 .Default(false);
276 Features["bpermd"] = llvm::StringSwitch<bool>(CPU)
277 .Case("ppc64le", true)
278 .Case("pwr9", true)
279 .Case("pwr8", true)
280 .Case("pwr7", true)
281 .Default(false);
282 Features["extdiv"] = llvm::StringSwitch<bool>(CPU)
283 .Case("ppc64le", true)
284 .Case("pwr9", true)
285 .Case("pwr8", true)
286 .Case("pwr7", true)
287 .Default(false);
288 Features["direct-move"] = llvm::StringSwitch<bool>(CPU)
289 .Case("ppc64le", true)
290 .Case("pwr9", true)
291 .Case("pwr8", true)
292 .Default(false);
293 Features["vsx"] = llvm::StringSwitch<bool>(CPU)
294 .Case("ppc64le", true)
295 .Case("pwr9", true)
296 .Case("pwr8", true)
297 .Case("pwr7", true)
298 .Default(false);
299 Features["htm"] = llvm::StringSwitch<bool>(CPU)
300 .Case("ppc64le", true)
301 .Case("pwr9", true)
302 .Case("pwr8", true)
303 .Default(false);
304
305 if (!ppcUserFeaturesCheck(Diags, FeaturesVec))
306 return false;
307
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]308 if (!(ArchDefs & ArchDefinePwr9) && (ArchDefs & ArchDefinePpcgr) &&
Fangrui Song75e74e02019-03-31 08:48:19 +0000[diff] [blame^]309 llvm::find(FeaturesVec, "+float128") != FeaturesVec.end()) {
Stefan Pintiliea6ce3fe2018-06-13 16:05:05 +0000[diff] [blame]310 // We have __float128 on PPC but not power 9 and above.
311 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfloat128" << CPU;
312 return false;
313 }
314
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]315 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
316}
317
318bool PPCTargetInfo::hasFeature(StringRef Feature) const {
319 return llvm::StringSwitch<bool>(Feature)
320 .Case("powerpc", true)
321 .Case("altivec", HasAltivec)
322 .Case("vsx", HasVSX)
323 .Case("power8-vector", HasP8Vector)
324 .Case("crypto", HasP8Crypto)
325 .Case("direct-move", HasDirectMove)
326 .Case("qpx", HasQPX)
327 .Case("htm", HasHTM)
328 .Case("bpermd", HasBPERMD)
329 .Case("extdiv", HasExtDiv)
330 .Case("float128", HasFloat128)
331 .Case("power9-vector", HasP9Vector)
332 .Default(false);
333}
334
335void PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
336 StringRef Name, bool Enabled) const {
337 if (Enabled) {
338 // If we're enabling any of the vsx based features then enable vsx and
339 // altivec. We'll diagnose any problems later.
340 bool FeatureHasVSX = llvm::StringSwitch<bool>(Name)
341 .Case("vsx", true)
342 .Case("direct-move", true)
343 .Case("power8-vector", true)
344 .Case("power9-vector", true)
345 .Case("float128", true)
346 .Default(false);
347 if (FeatureHasVSX)
348 Features["vsx"] = Features["altivec"] = true;
349 if (Name == "power9-vector")
350 Features["power8-vector"] = true;
351 Features[Name] = true;
352 } else {
353 // If we're disabling altivec or vsx go ahead and disable all of the vsx
354 // features.
355 if ((Name == "altivec") || (Name == "vsx"))
356 Features["vsx"] = Features["direct-move"] = Features["power8-vector"] =
357 Features["float128"] = Features["power9-vector"] = false;
358 if (Name == "power8-vector")
359 Features["power9-vector"] = false;
360 Features[Name] = false;
361 }
362}
363
364const char *const PPCTargetInfo::GCCRegNames[] = {
365 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8",
366 "r9", "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17",
367 "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26",
368 "r27", "r28", "r29", "r30", "r31", "f0", "f1", "f2", "f3",
369 "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12",
370 "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21",
371 "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29", "f30",
372 "f31", "mq", "lr", "ctr", "ap", "cr0", "cr1", "cr2", "cr3",
373 "cr4", "cr5", "cr6", "cr7", "xer", "v0", "v1", "v2", "v3",
374 "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11", "v12",
375 "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
376 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30",
377 "v31", "vrsave", "vscr", "spe_acc", "spefscr", "sfp"
378};
379
380ArrayRef<const char *> PPCTargetInfo::getGCCRegNames() const {
381 return llvm::makeArrayRef(GCCRegNames);
382}
383
384const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
385 // While some of these aliases do map to different registers
386 // they still share the same register name.
387 {{"0"}, "r0"}, {{"1"}, "r1"}, {{"2"}, "r2"}, {{"3"}, "r3"},
388 {{"4"}, "r4"}, {{"5"}, "r5"}, {{"6"}, "r6"}, {{"7"}, "r7"},
389 {{"8"}, "r8"}, {{"9"}, "r9"}, {{"10"}, "r10"}, {{"11"}, "r11"},
390 {{"12"}, "r12"}, {{"13"}, "r13"}, {{"14"}, "r14"}, {{"15"}, "r15"},
391 {{"16"}, "r16"}, {{"17"}, "r17"}, {{"18"}, "r18"}, {{"19"}, "r19"},
392 {{"20"}, "r20"}, {{"21"}, "r21"}, {{"22"}, "r22"}, {{"23"}, "r23"},
393 {{"24"}, "r24"}, {{"25"}, "r25"}, {{"26"}, "r26"}, {{"27"}, "r27"},
394 {{"28"}, "r28"}, {{"29"}, "r29"}, {{"30"}, "r30"}, {{"31"}, "r31"},
395 {{"fr0"}, "f0"}, {{"fr1"}, "f1"}, {{"fr2"}, "f2"}, {{"fr3"}, "f3"},
396 {{"fr4"}, "f4"}, {{"fr5"}, "f5"}, {{"fr6"}, "f6"}, {{"fr7"}, "f7"},
397 {{"fr8"}, "f8"}, {{"fr9"}, "f9"}, {{"fr10"}, "f10"}, {{"fr11"}, "f11"},
398 {{"fr12"}, "f12"}, {{"fr13"}, "f13"}, {{"fr14"}, "f14"}, {{"fr15"}, "f15"},
399 {{"fr16"}, "f16"}, {{"fr17"}, "f17"}, {{"fr18"}, "f18"}, {{"fr19"}, "f19"},
400 {{"fr20"}, "f20"}, {{"fr21"}, "f21"}, {{"fr22"}, "f22"}, {{"fr23"}, "f23"},
401 {{"fr24"}, "f24"}, {{"fr25"}, "f25"}, {{"fr26"}, "f26"}, {{"fr27"}, "f27"},
402 {{"fr28"}, "f28"}, {{"fr29"}, "f29"}, {{"fr30"}, "f30"}, {{"fr31"}, "f31"},
403 {{"cc"}, "cr0"},
404};
405
406ArrayRef<TargetInfo::GCCRegAlias> PPCTargetInfo::getGCCRegAliases() const {
407 return llvm::makeArrayRef(GCCRegAliases);
408}
409
Kang Zhang9606d582018-12-07 08:58:12 +0000[diff] [blame]410// PPC ELFABIv2 DWARF Definitoin "Table 2.26. Mappings of Common Registers".
411// vs0 ~ vs31 is mapping to 32 - 63,
412// vs32 ~ vs63 is mapping to 77 - 108.
413const TargetInfo::AddlRegName GCCAddlRegNames[] = {
414 // Table of additional register names to use in user input.
415 {{"vs0"}, 32}, {{"vs1"}, 33}, {{"vs2"}, 34}, {{"vs3"}, 35},
416 {{"vs4"}, 36}, {{"vs5"}, 37}, {{"vs6"}, 38}, {{"vs7"}, 39},
417 {{"vs8"}, 40}, {{"vs9"}, 41}, {{"vs10"}, 42}, {{"vs11"}, 43},
418 {{"vs12"}, 44}, {{"vs13"}, 45}, {{"vs14"}, 46}, {{"vs15"}, 47},
419 {{"vs16"}, 48}, {{"vs17"}, 49}, {{"vs18"}, 50}, {{"vs19"}, 51},
420 {{"vs20"}, 52}, {{"vs21"}, 53}, {{"vs22"}, 54}, {{"vs23"}, 55},
421 {{"vs24"}, 56}, {{"vs25"}, 57}, {{"vs26"}, 58}, {{"vs27"}, 59},
422 {{"vs28"}, 60}, {{"vs29"}, 61}, {{"vs30"}, 62}, {{"vs31"}, 63},
423 {{"vs32"}, 77}, {{"vs33"}, 78}, {{"vs34"}, 79}, {{"vs35"}, 80},
424 {{"vs36"}, 81}, {{"vs37"}, 82}, {{"vs38"}, 83}, {{"vs39"}, 84},
425 {{"vs40"}, 85}, {{"vs41"}, 86}, {{"vs42"}, 87}, {{"vs43"}, 88},
426 {{"vs44"}, 89}, {{"vs45"}, 90}, {{"vs46"}, 91}, {{"vs47"}, 92},
427 {{"vs48"}, 93}, {{"vs49"}, 94}, {{"vs50"}, 95}, {{"vs51"}, 96},
428 {{"vs52"}, 97}, {{"vs53"}, 98}, {{"vs54"}, 99}, {{"vs55"}, 100},
429 {{"vs56"}, 101}, {{"vs57"}, 102}, {{"vs58"}, 103}, {{"vs59"}, 104},
430 {{"vs60"}, 105}, {{"vs61"}, 106}, {{"vs62"}, 107}, {{"vs63"}, 108},
431};
432
433ArrayRef<TargetInfo::AddlRegName> PPCTargetInfo::getGCCAddlRegNames() const {
434 if (ABI == "elfv2")
435 return llvm::makeArrayRef(GCCAddlRegNames);
436 else
437 return TargetInfo::getGCCAddlRegNames();
438}
439
Erich Keanee44bdb32018-02-08 23:16:55 +0000[diff] [blame]440static constexpr llvm::StringLiteral ValidCPUNames[] = {
441 {"generic"}, {"440"}, {"450"}, {"601"}, {"602"},
442 {"603"}, {"603e"}, {"603ev"}, {"604"}, {"604e"},
443 {"620"}, {"630"}, {"g3"}, {"7400"}, {"g4"},
444 {"7450"}, {"g4+"}, {"750"}, {"970"}, {"g5"},
445 {"a2"}, {"a2q"}, {"e500mc"}, {"e5500"}, {"power3"},
446 {"pwr3"}, {"power4"}, {"pwr4"}, {"power5"}, {"pwr5"},
447 {"power5x"}, {"pwr5x"}, {"power6"}, {"pwr6"}, {"power6x"},
448 {"pwr6x"}, {"power7"}, {"pwr7"}, {"power8"}, {"pwr8"},
449 {"power9"}, {"pwr9"}, {"powerpc"}, {"ppc"}, {"powerpc64"},
450 {"ppc64"}, {"powerpc64le"}, {"ppc64le"},
451};
452
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]453bool PPCTargetInfo::isValidCPUName(StringRef Name) const {
Erich Keanefa69c712018-02-09 00:13:49 +0000[diff] [blame]454 return llvm::find(ValidCPUNames, Name) != std::end(ValidCPUNames);
Erich Keanee44bdb32018-02-08 23:16:55 +0000[diff] [blame]455}
456
457void PPCTargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {
458 Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
Erich Keaneebba5922017-07-21 22:37:03 +0000[diff] [blame]459}
460
461void PPCTargetInfo::adjust(LangOptions &Opts) {
462 if (HasAltivec)
463 Opts.AltiVec = 1;
464 TargetInfo::adjust(Opts);
465}
466
467ArrayRef<Builtin::Info> PPCTargetInfo::getTargetBuiltins() const {
468 return llvm::makeArrayRef(BuiltinInfo, clang::PPC::LastTSBuiltin -
469 Builtin::FirstTSBuiltin);
470}