1 //===--- TargetInfo.cpp - Information about Target machine ----------------===//
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 // This file implements the TargetInfo interface.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/Basic/TargetInfo.h"
14 #include "clang/Basic/AddressSpaces.h"
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/DiagnosticFrontend.h"
18 #include "clang/Basic/LangOptions.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/TargetParser/TargetParser.h"
23 #include <cstdlib>
24 using namespace clang;
25
26 static const LangASMap DefaultAddrSpaceMap = {0};
27 // The fake address space map must have a distinct entry for each
28 // language-specific address space.
29 static const LangASMap FakeAddrSpaceMap = {
30 0, // Default
31 1, // opencl_global
32 3, // opencl_local
33 2, // opencl_constant
34 0, // opencl_private
35 4, // opencl_generic
36 5, // opencl_global_device
37 6, // opencl_global_host
38 7, // cuda_device
39 8, // cuda_constant
40 9, // cuda_shared
41 1, // sycl_global
42 5, // sycl_global_device
43 6, // sycl_global_host
44 3, // sycl_local
45 0, // sycl_private
46 10, // ptr32_sptr
47 11, // ptr32_uptr
48 12, // ptr64
49 13, // hlsl_groupshared
50 20, // wasm_funcref
51 };
52
53 // TargetInfo Constructor.
TargetInfo(const llvm::Triple & T)54 TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
55 // Set defaults. Defaults are set for a 32-bit RISC platform, like PPC or
56 // SPARC. These should be overridden by concrete targets as needed.
57 BigEndian = !T.isLittleEndian();
58 TLSSupported = true;
59 VLASupported = true;
60 NoAsmVariants = false;
61 HasLegalHalfType = false;
62 HalfArgsAndReturns = false;
63 HasFloat128 = false;
64 HasIbm128 = false;
65 HasFloat16 = false;
66 HasBFloat16 = false;
67 HasFullBFloat16 = false;
68 HasLongDouble = true;
69 HasFPReturn = true;
70 HasStrictFP = false;
71 PointerWidth = PointerAlign = 32;
72 BoolWidth = BoolAlign = 8;
73 IntWidth = IntAlign = 32;
74 LongWidth = LongAlign = 32;
75 LongLongWidth = LongLongAlign = 64;
76 Int128Align = 128;
77
78 // Fixed point default bit widths
79 ShortAccumWidth = ShortAccumAlign = 16;
80 AccumWidth = AccumAlign = 32;
81 LongAccumWidth = LongAccumAlign = 64;
82 ShortFractWidth = ShortFractAlign = 8;
83 FractWidth = FractAlign = 16;
84 LongFractWidth = LongFractAlign = 32;
85
86 // Fixed point default integral and fractional bit sizes
87 // We give the _Accum 1 fewer fractional bits than their corresponding _Fract
88 // types by default to have the same number of fractional bits between _Accum
89 // and _Fract types.
90 PaddingOnUnsignedFixedPoint = false;
91 ShortAccumScale = 7;
92 AccumScale = 15;
93 LongAccumScale = 31;
94
95 SuitableAlign = 64;
96 DefaultAlignForAttributeAligned = 128;
97 MinGlobalAlign = 0;
98 // From the glibc documentation, on GNU systems, malloc guarantees 16-byte
99 // alignment on 64-bit systems and 8-byte alignment on 32-bit systems. See
100 // https://www.gnu.org/software/libc/manual/html_node/Malloc-Examples.html.
101 // This alignment guarantee also applies to Windows and Android. On Darwin
102 // and OpenBSD, the alignment is 16 bytes on both 64-bit and 32-bit systems.
103 if (T.isGNUEnvironment() || T.isWindowsMSVCEnvironment() || T.isAndroid() ||
104 T.isOHOSFamily())
105 NewAlign = Triple.isArch64Bit() ? 128 : Triple.isArch32Bit() ? 64 : 0;
106 else if (T.isOSDarwin() || T.isOSOpenBSD())
107 NewAlign = 128;
108 else
109 NewAlign = 0; // Infer from basic type alignment.
110 HalfWidth = 16;
111 HalfAlign = 16;
112 FloatWidth = 32;
113 FloatAlign = 32;
114 DoubleWidth = 64;
115 DoubleAlign = 64;
116 LongDoubleWidth = 64;
117 LongDoubleAlign = 64;
118 Float128Align = 128;
119 Ibm128Align = 128;
120 LargeArrayMinWidth = 0;
121 LargeArrayAlign = 0;
122 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
123 MaxVectorAlign = 0;
124 MaxTLSAlign = 0;
125 SizeType = UnsignedLong;
126 PtrDiffType = SignedLong;
127 IntMaxType = SignedLongLong;
128 IntPtrType = SignedLong;
129 WCharType = SignedInt;
130 WIntType = SignedInt;
131 Char16Type = UnsignedShort;
132 Char32Type = UnsignedInt;
133 Int64Type = SignedLongLong;
134 Int16Type = SignedShort;
135 SigAtomicType = SignedInt;
136 ProcessIDType = SignedInt;
137 UseSignedCharForObjCBool = true;
138 UseBitFieldTypeAlignment = true;
139 UseZeroLengthBitfieldAlignment = false;
140 UseLeadingZeroLengthBitfield = true;
141 UseExplicitBitFieldAlignment = true;
142 ZeroLengthBitfieldBoundary = 0;
143 MaxAlignedAttribute = 0;
144 HalfFormat = &llvm::APFloat::IEEEhalf();
145 FloatFormat = &llvm::APFloat::IEEEsingle();
146 DoubleFormat = &llvm::APFloat::IEEEdouble();
147 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
148 Float128Format = &llvm::APFloat::IEEEquad();
149 Ibm128Format = &llvm::APFloat::PPCDoubleDouble();
150 MCountName = "mcount";
151 UserLabelPrefix = "_";
152 RegParmMax = 0;
153 SSERegParmMax = 0;
154 HasAlignMac68kSupport = false;
155 HasBuiltinMSVaList = false;
156 IsRenderScriptTarget = false;
157 HasAArch64SVETypes = false;
158 HasRISCVVTypes = false;
159 AllowAMDGPUUnsafeFPAtomics = false;
160 ARMCDECoprocMask = 0;
161
162 // Default to no types using fpret.
163 RealTypeUsesObjCFPRetMask = 0;
164
165 // Default to not using fp2ret for __Complex long double
166 ComplexLongDoubleUsesFP2Ret = false;
167
168 // Set the C++ ABI based on the triple.
169 TheCXXABI.set(Triple.isKnownWindowsMSVCEnvironment()
170 ? TargetCXXABI::Microsoft
171 : TargetCXXABI::GenericItanium);
172
173 // Default to an empty address space map.
174 AddrSpaceMap = &DefaultAddrSpaceMap;
175 UseAddrSpaceMapMangling = false;
176
177 // Default to an unknown platform name.
178 PlatformName = "unknown";
179 PlatformMinVersion = VersionTuple();
180
181 MaxOpenCLWorkGroupSize = 1024;
182
183 MaxBitIntWidth.reset();
184 }
185
186 // Out of line virtual dtor for TargetInfo.
~TargetInfo()187 TargetInfo::~TargetInfo() {}
188
resetDataLayout(StringRef DL,const char * ULP)189 void TargetInfo::resetDataLayout(StringRef DL, const char *ULP) {
190 DataLayoutString = DL.str();
191 UserLabelPrefix = ULP;
192 }
193
194 bool
checkCFProtectionBranchSupported(DiagnosticsEngine & Diags) const195 TargetInfo::checkCFProtectionBranchSupported(DiagnosticsEngine &Diags) const {
196 Diags.Report(diag::err_opt_not_valid_on_target) << "cf-protection=branch";
197 return false;
198 }
199
200 bool
checkCFProtectionReturnSupported(DiagnosticsEngine & Diags) const201 TargetInfo::checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const {
202 Diags.Report(diag::err_opt_not_valid_on_target) << "cf-protection=return";
203 return false;
204 }
205
206 /// getTypeName - Return the user string for the specified integer type enum.
207 /// For example, SignedShort -> "short".
getTypeName(IntType T)208 const char *TargetInfo::getTypeName(IntType T) {
209 switch (T) {
210 default: llvm_unreachable("not an integer!");
211 case SignedChar: return "signed char";
212 case UnsignedChar: return "unsigned char";
213 case SignedShort: return "short";
214 case UnsignedShort: return "unsigned short";
215 case SignedInt: return "int";
216 case UnsignedInt: return "unsigned int";
217 case SignedLong: return "long int";
218 case UnsignedLong: return "long unsigned int";
219 case SignedLongLong: return "long long int";
220 case UnsignedLongLong: return "long long unsigned int";
221 }
222 }
223
224 /// getTypeConstantSuffix - Return the constant suffix for the specified
225 /// integer type enum. For example, SignedLong -> "L".
getTypeConstantSuffix(IntType T) const226 const char *TargetInfo::getTypeConstantSuffix(IntType T) const {
227 switch (T) {
228 default: llvm_unreachable("not an integer!");
229 case SignedChar:
230 case SignedShort:
231 case SignedInt: return "";
232 case SignedLong: return "L";
233 case SignedLongLong: return "LL";
234 case UnsignedChar:
235 if (getCharWidth() < getIntWidth())
236 return "";
237 [[fallthrough]];
238 case UnsignedShort:
239 if (getShortWidth() < getIntWidth())
240 return "";
241 [[fallthrough]];
242 case UnsignedInt: return "U";
243 case UnsignedLong: return "UL";
244 case UnsignedLongLong: return "ULL";
245 }
246 }
247
248 /// getTypeFormatModifier - Return the printf format modifier for the
249 /// specified integer type enum. For example, SignedLong -> "l".
250
getTypeFormatModifier(IntType T)251 const char *TargetInfo::getTypeFormatModifier(IntType T) {
252 switch (T) {
253 default: llvm_unreachable("not an integer!");
254 case SignedChar:
255 case UnsignedChar: return "hh";
256 case SignedShort:
257 case UnsignedShort: return "h";
258 case SignedInt:
259 case UnsignedInt: return "";
260 case SignedLong:
261 case UnsignedLong: return "l";
262 case SignedLongLong:
263 case UnsignedLongLong: return "ll";
264 }
265 }
266
267 /// getTypeWidth - Return the width (in bits) of the specified integer type
268 /// enum. For example, SignedInt -> getIntWidth().
getTypeWidth(IntType T) const269 unsigned TargetInfo::getTypeWidth(IntType T) const {
270 switch (T) {
271 default: llvm_unreachable("not an integer!");
272 case SignedChar:
273 case UnsignedChar: return getCharWidth();
274 case SignedShort:
275 case UnsignedShort: return getShortWidth();
276 case SignedInt:
277 case UnsignedInt: return getIntWidth();
278 case SignedLong:
279 case UnsignedLong: return getLongWidth();
280 case SignedLongLong:
281 case UnsignedLongLong: return getLongLongWidth();
282 };
283 }
284
getIntTypeByWidth(unsigned BitWidth,bool IsSigned) const285 TargetInfo::IntType TargetInfo::getIntTypeByWidth(
286 unsigned BitWidth, bool IsSigned) const {
287 if (getCharWidth() == BitWidth)
288 return IsSigned ? SignedChar : UnsignedChar;
289 if (getShortWidth() == BitWidth)
290 return IsSigned ? SignedShort : UnsignedShort;
291 if (getIntWidth() == BitWidth)
292 return IsSigned ? SignedInt : UnsignedInt;
293 if (getLongWidth() == BitWidth)
294 return IsSigned ? SignedLong : UnsignedLong;
295 if (getLongLongWidth() == BitWidth)
296 return IsSigned ? SignedLongLong : UnsignedLongLong;
297 return NoInt;
298 }
299
getLeastIntTypeByWidth(unsigned BitWidth,bool IsSigned) const300 TargetInfo::IntType TargetInfo::getLeastIntTypeByWidth(unsigned BitWidth,
301 bool IsSigned) const {
302 if (getCharWidth() >= BitWidth)
303 return IsSigned ? SignedChar : UnsignedChar;
304 if (getShortWidth() >= BitWidth)
305 return IsSigned ? SignedShort : UnsignedShort;
306 if (getIntWidth() >= BitWidth)
307 return IsSigned ? SignedInt : UnsignedInt;
308 if (getLongWidth() >= BitWidth)
309 return IsSigned ? SignedLong : UnsignedLong;
310 if (getLongLongWidth() >= BitWidth)
311 return IsSigned ? SignedLongLong : UnsignedLongLong;
312 return NoInt;
313 }
314
getRealTypeByWidth(unsigned BitWidth,FloatModeKind ExplicitType) const315 FloatModeKind TargetInfo::getRealTypeByWidth(unsigned BitWidth,
316 FloatModeKind ExplicitType) const {
317 if (getHalfWidth() == BitWidth)
318 return FloatModeKind::Half;
319 if (getFloatWidth() == BitWidth)
320 return FloatModeKind::Float;
321 if (getDoubleWidth() == BitWidth)
322 return FloatModeKind::Double;
323
324 switch (BitWidth) {
325 case 96:
326 if (&getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended())
327 return FloatModeKind::LongDouble;
328 break;
329 case 128:
330 // The caller explicitly asked for an IEEE compliant type but we still
331 // have to check if the target supports it.
332 if (ExplicitType == FloatModeKind::Float128)
333 return hasFloat128Type() ? FloatModeKind::Float128
334 : FloatModeKind::NoFloat;
335 if (ExplicitType == FloatModeKind::Ibm128)
336 return hasIbm128Type() ? FloatModeKind::Ibm128
337 : FloatModeKind::NoFloat;
338 if (&getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble() ||
339 &getLongDoubleFormat() == &llvm::APFloat::IEEEquad())
340 return FloatModeKind::LongDouble;
341 if (hasFloat128Type())
342 return FloatModeKind::Float128;
343 break;
344 }
345
346 return FloatModeKind::NoFloat;
347 }
348
349 /// getTypeAlign - Return the alignment (in bits) of the specified integer type
350 /// enum. For example, SignedInt -> getIntAlign().
getTypeAlign(IntType T) const351 unsigned TargetInfo::getTypeAlign(IntType T) const {
352 switch (T) {
353 default: llvm_unreachable("not an integer!");
354 case SignedChar:
355 case UnsignedChar: return getCharAlign();
356 case SignedShort:
357 case UnsignedShort: return getShortAlign();
358 case SignedInt:
359 case UnsignedInt: return getIntAlign();
360 case SignedLong:
361 case UnsignedLong: return getLongAlign();
362 case SignedLongLong:
363 case UnsignedLongLong: return getLongLongAlign();
364 };
365 }
366
367 /// isTypeSigned - Return whether an integer types is signed. Returns true if
368 /// the type is signed; false otherwise.
isTypeSigned(IntType T)369 bool TargetInfo::isTypeSigned(IntType T) {
370 switch (T) {
371 default: llvm_unreachable("not an integer!");
372 case SignedChar:
373 case SignedShort:
374 case SignedInt:
375 case SignedLong:
376 case SignedLongLong:
377 return true;
378 case UnsignedChar:
379 case UnsignedShort:
380 case UnsignedInt:
381 case UnsignedLong:
382 case UnsignedLongLong:
383 return false;
384 };
385 }
386
387 /// adjust - Set forced language options.
388 /// Apply changes to the target information with respect to certain
389 /// language options which change the target configuration and adjust
390 /// the language based on the target options where applicable.
adjust(DiagnosticsEngine & Diags,LangOptions & Opts)391 void TargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
392 if (Opts.NoBitFieldTypeAlign)
393 UseBitFieldTypeAlignment = false;
394
395 switch (Opts.WCharSize) {
396 default: llvm_unreachable("invalid wchar_t width");
397 case 0: break;
398 case 1: WCharType = Opts.WCharIsSigned ? SignedChar : UnsignedChar; break;
399 case 2: WCharType = Opts.WCharIsSigned ? SignedShort : UnsignedShort; break;
400 case 4: WCharType = Opts.WCharIsSigned ? SignedInt : UnsignedInt; break;
401 }
402
403 if (Opts.AlignDouble) {
404 DoubleAlign = LongLongAlign = 64;
405 LongDoubleAlign = 64;
406 }
407
408 if (Opts.OpenCL) {
409 // OpenCL C requires specific widths for types, irrespective of
410 // what these normally are for the target.
411 // We also define long long and long double here, although the
412 // OpenCL standard only mentions these as "reserved".
413 IntWidth = IntAlign = 32;
414 LongWidth = LongAlign = 64;
415 LongLongWidth = LongLongAlign = 128;
416 HalfWidth = HalfAlign = 16;
417 FloatWidth = FloatAlign = 32;
418
419 // Embedded 32-bit targets (OpenCL EP) might have double C type
420 // defined as float. Let's not override this as it might lead
421 // to generating illegal code that uses 64bit doubles.
422 if (DoubleWidth != FloatWidth) {
423 DoubleWidth = DoubleAlign = 64;
424 DoubleFormat = &llvm::APFloat::IEEEdouble();
425 }
426 LongDoubleWidth = LongDoubleAlign = 128;
427
428 unsigned MaxPointerWidth = getMaxPointerWidth();
429 assert(MaxPointerWidth == 32 || MaxPointerWidth == 64);
430 bool Is32BitArch = MaxPointerWidth == 32;
431 SizeType = Is32BitArch ? UnsignedInt : UnsignedLong;
432 PtrDiffType = Is32BitArch ? SignedInt : SignedLong;
433 IntPtrType = Is32BitArch ? SignedInt : SignedLong;
434
435 IntMaxType = SignedLongLong;
436 Int64Type = SignedLong;
437
438 HalfFormat = &llvm::APFloat::IEEEhalf();
439 FloatFormat = &llvm::APFloat::IEEEsingle();
440 LongDoubleFormat = &llvm::APFloat::IEEEquad();
441
442 // OpenCL C v3.0 s6.7.5 - The generic address space requires support for
443 // OpenCL C 2.0 or OpenCL C 3.0 with the __opencl_c_generic_address_space
444 // feature
445 // OpenCL C v3.0 s6.2.1 - OpenCL pipes require support of OpenCL C 2.0
446 // or later and __opencl_c_pipes feature
447 // FIXME: These language options are also defined in setLangDefaults()
448 // for OpenCL C 2.0 but with no access to target capabilities. Target
449 // should be immutable once created and thus these language options need
450 // to be defined only once.
451 if (Opts.getOpenCLCompatibleVersion() == 300) {
452 const auto &OpenCLFeaturesMap = getSupportedOpenCLOpts();
453 Opts.OpenCLGenericAddressSpace = hasFeatureEnabled(
454 OpenCLFeaturesMap, "__opencl_c_generic_address_space");
455 Opts.OpenCLPipes =
456 hasFeatureEnabled(OpenCLFeaturesMap, "__opencl_c_pipes");
457 Opts.Blocks =
458 hasFeatureEnabled(OpenCLFeaturesMap, "__opencl_c_device_enqueue");
459 }
460 }
461
462 if (Opts.DoubleSize) {
463 if (Opts.DoubleSize == 32) {
464 DoubleWidth = 32;
465 LongDoubleWidth = 32;
466 DoubleFormat = &llvm::APFloat::IEEEsingle();
467 LongDoubleFormat = &llvm::APFloat::IEEEsingle();
468 } else if (Opts.DoubleSize == 64) {
469 DoubleWidth = 64;
470 LongDoubleWidth = 64;
471 DoubleFormat = &llvm::APFloat::IEEEdouble();
472 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
473 }
474 }
475
476 if (Opts.LongDoubleSize) {
477 if (Opts.LongDoubleSize == DoubleWidth) {
478 LongDoubleWidth = DoubleWidth;
479 LongDoubleAlign = DoubleAlign;
480 LongDoubleFormat = DoubleFormat;
481 } else if (Opts.LongDoubleSize == 128) {
482 LongDoubleWidth = LongDoubleAlign = 128;
483 LongDoubleFormat = &llvm::APFloat::IEEEquad();
484 } else if (Opts.LongDoubleSize == 80) {
485 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
486 if (getTriple().isWindowsMSVCEnvironment()) {
487 LongDoubleWidth = 128;
488 LongDoubleAlign = 128;
489 } else { // Linux
490 if (getTriple().getArch() == llvm::Triple::x86) {
491 LongDoubleWidth = 96;
492 LongDoubleAlign = 32;
493 } else {
494 LongDoubleWidth = 128;
495 LongDoubleAlign = 128;
496 }
497 }
498 }
499 }
500
501 if (Opts.NewAlignOverride)
502 NewAlign = Opts.NewAlignOverride * getCharWidth();
503
504 // Each unsigned fixed point type has the same number of fractional bits as
505 // its corresponding signed type.
506 PaddingOnUnsignedFixedPoint |= Opts.PaddingOnUnsignedFixedPoint;
507 CheckFixedPointBits();
508
509 if (Opts.ProtectParens && !checkArithmeticFenceSupported()) {
510 Diags.Report(diag::err_opt_not_valid_on_target) << "-fprotect-parens";
511 Opts.ProtectParens = false;
512 }
513
514 if (Opts.MaxBitIntWidth)
515 MaxBitIntWidth = static_cast<unsigned>(Opts.MaxBitIntWidth);
516
517 if (Opts.FakeAddressSpaceMap)
518 AddrSpaceMap = &FakeAddrSpaceMap;
519 }
520
initFeatureMap(llvm::StringMap<bool> & Features,DiagnosticsEngine & Diags,StringRef CPU,const std::vector<std::string> & FeatureVec) const521 bool TargetInfo::initFeatureMap(
522 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
523 const std::vector<std::string> &FeatureVec) const {
524 for (const auto &F : FeatureVec) {
525 StringRef Name = F;
526 if (Name.empty())
527 continue;
528 // Apply the feature via the target.
529 if (Name[0] != '+' && Name[0] != '-')
530 Diags.Report(diag::warn_fe_backend_invalid_feature_flag) << Name;
531 else
532 setFeatureEnabled(Features, Name.substr(1), Name[0] == '+');
533 }
534 return true;
535 }
536
parseTargetAttr(StringRef Features) const537 ParsedTargetAttr TargetInfo::parseTargetAttr(StringRef Features) const {
538 ParsedTargetAttr Ret;
539 if (Features == "default")
540 return Ret;
541 SmallVector<StringRef, 1> AttrFeatures;
542 Features.split(AttrFeatures, ",");
543
544 // Grab the various features and prepend a "+" to turn on the feature to
545 // the backend and add them to our existing set of features.
546 for (auto &Feature : AttrFeatures) {
547 // Go ahead and trim whitespace rather than either erroring or
548 // accepting it weirdly.
549 Feature = Feature.trim();
550
551 // TODO: Support the fpmath option. It will require checking
552 // overall feature validity for the function with the rest of the
553 // attributes on the function.
554 if (Feature.starts_with("fpmath="))
555 continue;
556
557 if (Feature.starts_with("branch-protection=")) {
558 Ret.BranchProtection = Feature.split('=').second.trim();
559 continue;
560 }
561
562 // While we're here iterating check for a different target cpu.
563 if (Feature.starts_with("arch=")) {
564 if (!Ret.CPU.empty())
565 Ret.Duplicate = "arch=";
566 else
567 Ret.CPU = Feature.split("=").second.trim();
568 } else if (Feature.starts_with("tune=")) {
569 if (!Ret.Tune.empty())
570 Ret.Duplicate = "tune=";
571 else
572 Ret.Tune = Feature.split("=").second.trim();
573 } else if (Feature.starts_with("no-"))
574 Ret.Features.push_back("-" + Feature.split("-").second.str());
575 else
576 Ret.Features.push_back("+" + Feature.str());
577 }
578 return Ret;
579 }
580
581 TargetInfo::CallingConvKind
getCallingConvKind(bool ClangABICompat4) const582 TargetInfo::getCallingConvKind(bool ClangABICompat4) const {
583 if (getCXXABI() != TargetCXXABI::Microsoft &&
584 (ClangABICompat4 || getTriple().isPS4()))
585 return CCK_ClangABI4OrPS4;
586 return CCK_Default;
587 }
588
areDefaultedSMFStillPOD(const LangOptions & LangOpts) const589 bool TargetInfo::areDefaultedSMFStillPOD(const LangOptions &LangOpts) const {
590 return LangOpts.getClangABICompat() > LangOptions::ClangABI::Ver15;
591 }
592
getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const593 LangAS TargetInfo::getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const {
594 switch (TK) {
595 case OCLTK_Image:
596 case OCLTK_Pipe:
597 return LangAS::opencl_global;
598
599 case OCLTK_Sampler:
600 return LangAS::opencl_constant;
601
602 default:
603 return LangAS::Default;
604 }
605 }
606
607 //===----------------------------------------------------------------------===//
608
609
removeGCCRegisterPrefix(StringRef Name)610 static StringRef removeGCCRegisterPrefix(StringRef Name) {
611 if (Name[0] == '%' || Name[0] == '#')
612 Name = Name.substr(1);
613
614 return Name;
615 }
616
617 /// isValidClobber - Returns whether the passed in string is
618 /// a valid clobber in an inline asm statement. This is used by
619 /// Sema.
isValidClobber(StringRef Name) const620 bool TargetInfo::isValidClobber(StringRef Name) const {
621 return (isValidGCCRegisterName(Name) || Name == "memory" || Name == "cc" ||
622 Name == "unwind");
623 }
624
625 /// isValidGCCRegisterName - Returns whether the passed in string
626 /// is a valid register name according to GCC. This is used by Sema for
627 /// inline asm statements.
isValidGCCRegisterName(StringRef Name) const628 bool TargetInfo::isValidGCCRegisterName(StringRef Name) const {
629 if (Name.empty())
630 return false;
631
632 // Get rid of any register prefix.
633 Name = removeGCCRegisterPrefix(Name);
634 if (Name.empty())
635 return false;
636
637 ArrayRef<const char *> Names = getGCCRegNames();
638
639 // If we have a number it maps to an entry in the register name array.
640 if (isDigit(Name[0])) {
641 unsigned n;
642 if (!Name.getAsInteger(0, n))
643 return n < Names.size();
644 }
645
646 // Check register names.
647 if (llvm::is_contained(Names, Name))
648 return true;
649
650 // Check any additional names that we have.
651 for (const AddlRegName &ARN : getGCCAddlRegNames())
652 for (const char *AN : ARN.Names) {
653 if (!AN)
654 break;
655 // Make sure the register that the additional name is for is within
656 // the bounds of the register names from above.
657 if (AN == Name && ARN.RegNum < Names.size())
658 return true;
659 }
660
661 // Now check aliases.
662 for (const GCCRegAlias &GRA : getGCCRegAliases())
663 for (const char *A : GRA.Aliases) {
664 if (!A)
665 break;
666 if (A == Name)
667 return true;
668 }
669
670 return false;
671 }
672
getNormalizedGCCRegisterName(StringRef Name,bool ReturnCanonical) const673 StringRef TargetInfo::getNormalizedGCCRegisterName(StringRef Name,
674 bool ReturnCanonical) const {
675 assert(isValidGCCRegisterName(Name) && "Invalid register passed in");
676
677 // Get rid of any register prefix.
678 Name = removeGCCRegisterPrefix(Name);
679
680 ArrayRef<const char *> Names = getGCCRegNames();
681
682 // First, check if we have a number.
683 if (isDigit(Name[0])) {
684 unsigned n;
685 if (!Name.getAsInteger(0, n)) {
686 assert(n < Names.size() && "Out of bounds register number!");
687 return Names[n];
688 }
689 }
690
691 // Check any additional names that we have.
692 for (const AddlRegName &ARN : getGCCAddlRegNames())
693 for (const char *AN : ARN.Names) {
694 if (!AN)
695 break;
696 // Make sure the register that the additional name is for is within
697 // the bounds of the register names from above.
698 if (AN == Name && ARN.RegNum < Names.size())
699 return ReturnCanonical ? Names[ARN.RegNum] : Name;
700 }
701
702 // Now check aliases.
703 for (const GCCRegAlias &RA : getGCCRegAliases())
704 for (const char *A : RA.Aliases) {
705 if (!A)
706 break;
707 if (A == Name)
708 return RA.Register;
709 }
710
711 return Name;
712 }
713
validateOutputConstraint(ConstraintInfo & Info) const714 bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const {
715 const char *Name = Info.getConstraintStr().c_str();
716 // An output constraint must start with '=' or '+'
717 if (*Name != '=' && *Name != '+')
718 return false;
719
720 if (*Name == '+')
721 Info.setIsReadWrite();
722
723 Name++;
724 while (*Name) {
725 switch (*Name) {
726 default:
727 if (!validateAsmConstraint(Name, Info)) {
728 // FIXME: We temporarily return false
729 // so we can add more constraints as we hit it.
730 // Eventually, an unknown constraint should just be treated as 'g'.
731 return false;
732 }
733 break;
734 case '&': // early clobber.
735 Info.setEarlyClobber();
736 break;
737 case '%': // commutative.
738 // FIXME: Check that there is a another register after this one.
739 break;
740 case 'r': // general register.
741 Info.setAllowsRegister();
742 break;
743 case 'm': // memory operand.
744 case 'o': // offsetable memory operand.
745 case 'V': // non-offsetable memory operand.
746 case '<': // autodecrement memory operand.
747 case '>': // autoincrement memory operand.
748 Info.setAllowsMemory();
749 break;
750 case 'g': // general register, memory operand or immediate integer.
751 case 'X': // any operand.
752 Info.setAllowsRegister();
753 Info.setAllowsMemory();
754 break;
755 case ',': // multiple alternative constraint. Pass it.
756 // Handle additional optional '=' or '+' modifiers.
757 if (Name[1] == '=' || Name[1] == '+')
758 Name++;
759 break;
760 case '#': // Ignore as constraint.
761 while (Name[1] && Name[1] != ',')
762 Name++;
763 break;
764 case '?': // Disparage slightly code.
765 case '!': // Disparage severely.
766 case '*': // Ignore for choosing register preferences.
767 case 'i': // Ignore i,n,E,F as output constraints (match from the other
768 // chars)
769 case 'n':
770 case 'E':
771 case 'F':
772 break; // Pass them.
773 }
774
775 Name++;
776 }
777
778 // Early clobber with a read-write constraint which doesn't permit registers
779 // is invalid.
780 if (Info.earlyClobber() && Info.isReadWrite() && !Info.allowsRegister())
781 return false;
782
783 // If a constraint allows neither memory nor register operands it contains
784 // only modifiers. Reject it.
785 return Info.allowsMemory() || Info.allowsRegister();
786 }
787
resolveSymbolicName(const char * & Name,ArrayRef<ConstraintInfo> OutputConstraints,unsigned & Index) const788 bool TargetInfo::resolveSymbolicName(const char *&Name,
789 ArrayRef<ConstraintInfo> OutputConstraints,
790 unsigned &Index) const {
791 assert(*Name == '[' && "Symbolic name did not start with '['");
792 Name++;
793 const char *Start = Name;
794 while (*Name && *Name != ']')
795 Name++;
796
797 if (!*Name) {
798 // Missing ']'
799 return false;
800 }
801
802 std::string SymbolicName(Start, Name - Start);
803
804 for (Index = 0; Index != OutputConstraints.size(); ++Index)
805 if (SymbolicName == OutputConstraints[Index].getName())
806 return true;
807
808 return false;
809 }
810
validateInputConstraint(MutableArrayRef<ConstraintInfo> OutputConstraints,ConstraintInfo & Info) const811 bool TargetInfo::validateInputConstraint(
812 MutableArrayRef<ConstraintInfo> OutputConstraints,
813 ConstraintInfo &Info) const {
814 const char *Name = Info.ConstraintStr.c_str();
815
816 if (!*Name)
817 return false;
818
819 while (*Name) {
820 switch (*Name) {
821 default:
822 // Check if we have a matching constraint
823 if (*Name >= '0' && *Name <= '9') {
824 const char *DigitStart = Name;
825 while (Name[1] >= '0' && Name[1] <= '9')
826 Name++;
827 const char *DigitEnd = Name;
828 unsigned i;
829 if (StringRef(DigitStart, DigitEnd - DigitStart + 1)
830 .getAsInteger(10, i))
831 return false;
832
833 // Check if matching constraint is out of bounds.
834 if (i >= OutputConstraints.size()) return false;
835
836 // A number must refer to an output only operand.
837 if (OutputConstraints[i].isReadWrite())
838 return false;
839
840 // If the constraint is already tied, it must be tied to the
841 // same operand referenced to by the number.
842 if (Info.hasTiedOperand() && Info.getTiedOperand() != i)
843 return false;
844
845 // The constraint should have the same info as the respective
846 // output constraint.
847 Info.setTiedOperand(i, OutputConstraints[i]);
848 } else if (!validateAsmConstraint(Name, Info)) {
849 // FIXME: This error return is in place temporarily so we can
850 // add more constraints as we hit it. Eventually, an unknown
851 // constraint should just be treated as 'g'.
852 return false;
853 }
854 break;
855 case '[': {
856 unsigned Index = 0;
857 if (!resolveSymbolicName(Name, OutputConstraints, Index))
858 return false;
859
860 // If the constraint is already tied, it must be tied to the
861 // same operand referenced to by the number.
862 if (Info.hasTiedOperand() && Info.getTiedOperand() != Index)
863 return false;
864
865 // A number must refer to an output only operand.
866 if (OutputConstraints[Index].isReadWrite())
867 return false;
868
869 Info.setTiedOperand(Index, OutputConstraints[Index]);
870 break;
871 }
872 case '%': // commutative
873 // FIXME: Fail if % is used with the last operand.
874 break;
875 case 'i': // immediate integer.
876 break;
877 case 'n': // immediate integer with a known value.
878 Info.setRequiresImmediate();
879 break;
880 case 'I': // Various constant constraints with target-specific meanings.
881 case 'J':
882 case 'K':
883 case 'L':
884 case 'M':
885 case 'N':
886 case 'O':
887 case 'P':
888 if (!validateAsmConstraint(Name, Info))
889 return false;
890 break;
891 case 'r': // general register.
892 Info.setAllowsRegister();
893 break;
894 case 'm': // memory operand.
895 case 'o': // offsettable memory operand.
896 case 'V': // non-offsettable memory operand.
897 case '<': // autodecrement memory operand.
898 case '>': // autoincrement memory operand.
899 Info.setAllowsMemory();
900 break;
901 case 'g': // general register, memory operand or immediate integer.
902 case 'X': // any operand.
903 Info.setAllowsRegister();
904 Info.setAllowsMemory();
905 break;
906 case 'E': // immediate floating point.
907 case 'F': // immediate floating point.
908 case 'p': // address operand.
909 break;
910 case ',': // multiple alternative constraint. Ignore comma.
911 break;
912 case '#': // Ignore as constraint.
913 while (Name[1] && Name[1] != ',')
914 Name++;
915 break;
916 case '?': // Disparage slightly code.
917 case '!': // Disparage severely.
918 case '*': // Ignore for choosing register preferences.
919 break; // Pass them.
920 }
921
922 Name++;
923 }
924
925 return true;
926 }
927
CheckFixedPointBits() const928 void TargetInfo::CheckFixedPointBits() const {
929 // Check that the number of fractional and integral bits (and maybe sign) can
930 // fit into the bits given for a fixed point type.
931 assert(ShortAccumScale + getShortAccumIBits() + 1 <= ShortAccumWidth);
932 assert(AccumScale + getAccumIBits() + 1 <= AccumWidth);
933 assert(LongAccumScale + getLongAccumIBits() + 1 <= LongAccumWidth);
934 assert(getUnsignedShortAccumScale() + getUnsignedShortAccumIBits() <=
935 ShortAccumWidth);
936 assert(getUnsignedAccumScale() + getUnsignedAccumIBits() <= AccumWidth);
937 assert(getUnsignedLongAccumScale() + getUnsignedLongAccumIBits() <=
938 LongAccumWidth);
939
940 assert(getShortFractScale() + 1 <= ShortFractWidth);
941 assert(getFractScale() + 1 <= FractWidth);
942 assert(getLongFractScale() + 1 <= LongFractWidth);
943 assert(getUnsignedShortFractScale() <= ShortFractWidth);
944 assert(getUnsignedFractScale() <= FractWidth);
945 assert(getUnsignedLongFractScale() <= LongFractWidth);
946
947 // Each unsigned fract type has either the same number of fractional bits
948 // as, or one more fractional bit than, its corresponding signed fract type.
949 assert(getShortFractScale() == getUnsignedShortFractScale() ||
950 getShortFractScale() == getUnsignedShortFractScale() - 1);
951 assert(getFractScale() == getUnsignedFractScale() ||
952 getFractScale() == getUnsignedFractScale() - 1);
953 assert(getLongFractScale() == getUnsignedLongFractScale() ||
954 getLongFractScale() == getUnsignedLongFractScale() - 1);
955
956 // When arranged in order of increasing rank (see 6.3.1.3a), the number of
957 // fractional bits is nondecreasing for each of the following sets of
958 // fixed-point types:
959 // - signed fract types
960 // - unsigned fract types
961 // - signed accum types
962 // - unsigned accum types.
963 assert(getLongFractScale() >= getFractScale() &&
964 getFractScale() >= getShortFractScale());
965 assert(getUnsignedLongFractScale() >= getUnsignedFractScale() &&
966 getUnsignedFractScale() >= getUnsignedShortFractScale());
967 assert(LongAccumScale >= AccumScale && AccumScale >= ShortAccumScale);
968 assert(getUnsignedLongAccumScale() >= getUnsignedAccumScale() &&
969 getUnsignedAccumScale() >= getUnsignedShortAccumScale());
970
971 // When arranged in order of increasing rank (see 6.3.1.3a), the number of
972 // integral bits is nondecreasing for each of the following sets of
973 // fixed-point types:
974 // - signed accum types
975 // - unsigned accum types
976 assert(getLongAccumIBits() >= getAccumIBits() &&
977 getAccumIBits() >= getShortAccumIBits());
978 assert(getUnsignedLongAccumIBits() >= getUnsignedAccumIBits() &&
979 getUnsignedAccumIBits() >= getUnsignedShortAccumIBits());
980
981 // Each signed accum type has at least as many integral bits as its
982 // corresponding unsigned accum type.
983 assert(getShortAccumIBits() >= getUnsignedShortAccumIBits());
984 assert(getAccumIBits() >= getUnsignedAccumIBits());
985 assert(getLongAccumIBits() >= getUnsignedLongAccumIBits());
986 }
987
copyAuxTarget(const TargetInfo * Aux)988 void TargetInfo::copyAuxTarget(const TargetInfo *Aux) {
989 auto *Target = static_cast<TransferrableTargetInfo*>(this);
990 auto *Src = static_cast<const TransferrableTargetInfo*>(Aux);
991 *Target = *Src;
992 }
993