1 //===--- TargetInfo.h - Expose information about the target -----*- C++ -*-===// 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 /// \file 11 /// Defines the clang::TargetInfo interface. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_BASIC_TARGETINFO_H 16 #define LLVM_CLANG_BASIC_TARGETINFO_H 17 18 #include "clang/Basic/AddressSpaces.h" 19 #include "clang/Basic/LLVM.h" 20 #include "clang/Basic/Specifiers.h" 21 #include "clang/Basic/TargetCXXABI.h" 22 #include "clang/Basic/TargetOptions.h" 23 #include "llvm/ADT/APInt.h" 24 #include "llvm/ADT/IntrusiveRefCntPtr.h" 25 #include "llvm/ADT/Optional.h" 26 #include "llvm/ADT/SmallSet.h" 27 #include "llvm/ADT/StringMap.h" 28 #include "llvm/ADT/StringRef.h" 29 #include "llvm/ADT/Triple.h" 30 #include "llvm/IR/DataLayout.h" 31 #include "llvm/Support/DataTypes.h" 32 #include "llvm/Support/VersionTuple.h" 33 #include <cassert> 34 #include <string> 35 #include <vector> 36 37 namespace llvm { 38 struct fltSemantics; 39 } 40 41 namespace clang { 42 class DiagnosticsEngine; 43 class LangOptions; 44 class CodeGenOptions; 45 class MacroBuilder; 46 class QualType; 47 class SourceLocation; 48 class SourceManager; 49 50 namespace Builtin { struct Info; } 51 52 /// Exposes information about the current target. 53 /// 54 class TargetInfo : public RefCountedBase<TargetInfo> { 55 std::shared_ptr<TargetOptions> TargetOpts; 56 llvm::Triple Triple; 57 protected: 58 // Target values set by the ctor of the actual target implementation. Default 59 // values are specified by the TargetInfo constructor. 60 bool BigEndian; 61 bool TLSSupported; 62 bool VLASupported; 63 bool NoAsmVariants; // True if {|} are normal characters. 64 bool HasLegalHalfType; // True if the backend supports operations on the half 65 // LLVM IR type. 66 bool HasFloat128; 67 unsigned char PointerWidth, PointerAlign; 68 unsigned char BoolWidth, BoolAlign; 69 unsigned char IntWidth, IntAlign; 70 unsigned char HalfWidth, HalfAlign; 71 unsigned char FloatWidth, FloatAlign; 72 unsigned char DoubleWidth, DoubleAlign; 73 unsigned char LongDoubleWidth, LongDoubleAlign, Float128Align; 74 unsigned char LargeArrayMinWidth, LargeArrayAlign; 75 unsigned char LongWidth, LongAlign; 76 unsigned char LongLongWidth, LongLongAlign; 77 78 // Fixed point bit widths 79 unsigned char ShortAccumWidth, ShortAccumAlign; 80 unsigned char AccumWidth, AccumAlign; 81 unsigned char LongAccumWidth, LongAccumAlign; 82 unsigned char ShortFractWidth, ShortFractAlign; 83 unsigned char FractWidth, FractAlign; 84 unsigned char LongFractWidth, LongFractAlign; 85 86 // If true, unsigned fixed point types have the same number of fractional bits 87 // as their signed counterparts, forcing the unsigned types to have one extra 88 // bit of padding. Otherwise, unsigned fixed point types have 89 // one more fractional bit than its corresponding signed type. This is false 90 // by default. 91 bool PaddingOnUnsignedFixedPoint; 92 93 // Fixed point integral and fractional bit sizes 94 // Saturated types share the same integral/fractional bits as their 95 // corresponding unsaturated types. 96 // For simplicity, the fractional bits in a _Fract type will be one less the 97 // width of that _Fract type. This leaves all signed _Fract types having no 98 // padding and unsigned _Fract types will only have 1 bit of padding after the 99 // sign if PaddingOnUnsignedFixedPoint is set. 100 unsigned char ShortAccumScale; 101 unsigned char AccumScale; 102 unsigned char LongAccumScale; 103 104 unsigned char SuitableAlign; 105 unsigned char DefaultAlignForAttributeAligned; 106 unsigned char MinGlobalAlign; 107 unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth; 108 unsigned short MaxVectorAlign; 109 unsigned short MaxTLSAlign; 110 unsigned short SimdDefaultAlign; 111 unsigned short NewAlign; 112 std::unique_ptr<llvm::DataLayout> DataLayout; 113 const char *MCountName; 114 const llvm::fltSemantics *HalfFormat, *FloatFormat, *DoubleFormat, 115 *LongDoubleFormat, *Float128Format; 116 unsigned char RegParmMax, SSERegParmMax; 117 TargetCXXABI TheCXXABI; 118 const LangASMap *AddrSpaceMap; 119 120 mutable StringRef PlatformName; 121 mutable VersionTuple PlatformMinVersion; 122 123 unsigned HasAlignMac68kSupport : 1; 124 unsigned RealTypeUsesObjCFPRet : 3; 125 unsigned ComplexLongDoubleUsesFP2Ret : 1; 126 127 unsigned HasBuiltinMSVaList : 1; 128 129 unsigned IsRenderScriptTarget : 1; 130 131 // TargetInfo Constructor. Default initializes all fields. 132 TargetInfo(const llvm::Triple &T); 133 resetDataLayout(StringRef DL)134 void resetDataLayout(StringRef DL) { 135 DataLayout.reset(new llvm::DataLayout(DL)); 136 } 137 138 public: 139 /// Construct a target for the given options. 140 /// 141 /// \param Opts - The options to use to initialize the target. The target may 142 /// modify the options to canonicalize the target feature information to match 143 /// what the backend expects. 144 static TargetInfo * 145 CreateTargetInfo(DiagnosticsEngine &Diags, 146 const std::shared_ptr<TargetOptions> &Opts); 147 148 virtual ~TargetInfo(); 149 150 /// Retrieve the target options. getTargetOpts()151 TargetOptions &getTargetOpts() const { 152 assert(TargetOpts && "Missing target options"); 153 return *TargetOpts; 154 } 155 156 ///===---- Target Data Type Query Methods -------------------------------===// 157 enum IntType { 158 NoInt = 0, 159 SignedChar, 160 UnsignedChar, 161 SignedShort, 162 UnsignedShort, 163 SignedInt, 164 UnsignedInt, 165 SignedLong, 166 UnsignedLong, 167 SignedLongLong, 168 UnsignedLongLong 169 }; 170 171 enum RealType { 172 NoFloat = 255, 173 Float = 0, 174 Double, 175 LongDouble, 176 Float128 177 }; 178 179 /// The different kinds of __builtin_va_list types defined by 180 /// the target implementation. 181 enum BuiltinVaListKind { 182 /// typedef char* __builtin_va_list; 183 CharPtrBuiltinVaList = 0, 184 185 /// typedef void* __builtin_va_list; 186 VoidPtrBuiltinVaList, 187 188 /// __builtin_va_list as defined by the AArch64 ABI 189 /// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055a/IHI0055A_aapcs64.pdf 190 AArch64ABIBuiltinVaList, 191 192 /// __builtin_va_list as defined by the PNaCl ABI: 193 /// http://www.chromium.org/nativeclient/pnacl/bitcode-abi#TOC-Machine-Types 194 PNaClABIBuiltinVaList, 195 196 /// __builtin_va_list as defined by the Power ABI: 197 /// https://www.power.org 198 /// /resources/downloads/Power-Arch-32-bit-ABI-supp-1.0-Embedded.pdf 199 PowerABIBuiltinVaList, 200 201 /// __builtin_va_list as defined by the x86-64 ABI: 202 /// http://refspecs.linuxbase.org/elf/x86_64-abi-0.21.pdf 203 X86_64ABIBuiltinVaList, 204 205 /// __builtin_va_list as defined by ARM AAPCS ABI 206 /// http://infocenter.arm.com 207 // /help/topic/com.arm.doc.ihi0042d/IHI0042D_aapcs.pdf 208 AAPCSABIBuiltinVaList, 209 210 // typedef struct __va_list_tag 211 // { 212 // long __gpr; 213 // long __fpr; 214 // void *__overflow_arg_area; 215 // void *__reg_save_area; 216 // } va_list[1]; 217 SystemZBuiltinVaList 218 }; 219 220 protected: 221 IntType SizeType, IntMaxType, PtrDiffType, IntPtrType, WCharType, 222 WIntType, Char16Type, Char32Type, Int64Type, SigAtomicType, 223 ProcessIDType; 224 225 /// Whether Objective-C's built-in boolean type should be signed char. 226 /// 227 /// Otherwise, when this flag is not set, the normal built-in boolean type is 228 /// used. 229 unsigned UseSignedCharForObjCBool : 1; 230 231 /// Control whether the alignment of bit-field types is respected when laying 232 /// out structures. If true, then the alignment of the bit-field type will be 233 /// used to (a) impact the alignment of the containing structure, and (b) 234 /// ensure that the individual bit-field will not straddle an alignment 235 /// boundary. 236 unsigned UseBitFieldTypeAlignment : 1; 237 238 /// Whether zero length bitfields (e.g., int : 0;) force alignment of 239 /// the next bitfield. 240 /// 241 /// If the alignment of the zero length bitfield is greater than the member 242 /// that follows it, `bar', `bar' will be aligned as the type of the 243 /// zero-length bitfield. 244 unsigned UseZeroLengthBitfieldAlignment : 1; 245 246 /// Whether explicit bit field alignment attributes are honored. 247 unsigned UseExplicitBitFieldAlignment : 1; 248 249 /// If non-zero, specifies a fixed alignment value for bitfields that follow 250 /// zero length bitfield, regardless of the zero length bitfield type. 251 unsigned ZeroLengthBitfieldBoundary; 252 253 /// Specify if mangling based on address space map should be used or 254 /// not for language specific address spaces 255 bool UseAddrSpaceMapMangling; 256 257 public: getSizeType()258 IntType getSizeType() const { return SizeType; } getSignedSizeType()259 IntType getSignedSizeType() const { 260 switch (SizeType) { 261 case UnsignedShort: 262 return SignedShort; 263 case UnsignedInt: 264 return SignedInt; 265 case UnsignedLong: 266 return SignedLong; 267 case UnsignedLongLong: 268 return SignedLongLong; 269 default: 270 llvm_unreachable("Invalid SizeType"); 271 } 272 } getIntMaxType()273 IntType getIntMaxType() const { return IntMaxType; } getUIntMaxType()274 IntType getUIntMaxType() const { 275 return getCorrespondingUnsignedType(IntMaxType); 276 } getPtrDiffType(unsigned AddrSpace)277 IntType getPtrDiffType(unsigned AddrSpace) const { 278 return AddrSpace == 0 ? PtrDiffType : getPtrDiffTypeV(AddrSpace); 279 } getUnsignedPtrDiffType(unsigned AddrSpace)280 IntType getUnsignedPtrDiffType(unsigned AddrSpace) const { 281 return getCorrespondingUnsignedType(getPtrDiffType(AddrSpace)); 282 } getIntPtrType()283 IntType getIntPtrType() const { return IntPtrType; } getUIntPtrType()284 IntType getUIntPtrType() const { 285 return getCorrespondingUnsignedType(IntPtrType); 286 } getWCharType()287 IntType getWCharType() const { return WCharType; } getWIntType()288 IntType getWIntType() const { return WIntType; } getChar16Type()289 IntType getChar16Type() const { return Char16Type; } getChar32Type()290 IntType getChar32Type() const { return Char32Type; } getInt64Type()291 IntType getInt64Type() const { return Int64Type; } getUInt64Type()292 IntType getUInt64Type() const { 293 return getCorrespondingUnsignedType(Int64Type); 294 } getSigAtomicType()295 IntType getSigAtomicType() const { return SigAtomicType; } getProcessIDType()296 IntType getProcessIDType() const { return ProcessIDType; } 297 getCorrespondingUnsignedType(IntType T)298 static IntType getCorrespondingUnsignedType(IntType T) { 299 switch (T) { 300 case SignedChar: 301 return UnsignedChar; 302 case SignedShort: 303 return UnsignedShort; 304 case SignedInt: 305 return UnsignedInt; 306 case SignedLong: 307 return UnsignedLong; 308 case SignedLongLong: 309 return UnsignedLongLong; 310 default: 311 llvm_unreachable("Unexpected signed integer type"); 312 } 313 } 314 315 /// Return the width (in bits) of the specified integer type enum. 316 /// 317 /// For example, SignedInt -> getIntWidth(). 318 unsigned getTypeWidth(IntType T) const; 319 320 /// Return integer type with specified width. 321 virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const; 322 323 /// Return the smallest integer type with at least the specified width. 324 virtual IntType getLeastIntTypeByWidth(unsigned BitWidth, 325 bool IsSigned) const; 326 327 /// Return floating point type with specified width. 328 RealType getRealTypeByWidth(unsigned BitWidth) const; 329 330 /// Return the alignment (in bits) of the specified integer type enum. 331 /// 332 /// For example, SignedInt -> getIntAlign(). 333 unsigned getTypeAlign(IntType T) const; 334 335 /// Returns true if the type is signed; false otherwise. 336 static bool isTypeSigned(IntType T); 337 338 /// Return the width of pointers on this target, for the 339 /// specified address space. getPointerWidth(unsigned AddrSpace)340 uint64_t getPointerWidth(unsigned AddrSpace) const { 341 return AddrSpace == 0 ? PointerWidth : getPointerWidthV(AddrSpace); 342 } getPointerAlign(unsigned AddrSpace)343 uint64_t getPointerAlign(unsigned AddrSpace) const { 344 return AddrSpace == 0 ? PointerAlign : getPointerAlignV(AddrSpace); 345 } 346 347 /// Return the maximum width of pointers on this target. getMaxPointerWidth()348 virtual uint64_t getMaxPointerWidth() const { 349 return PointerWidth; 350 } 351 352 /// Get integer value for null pointer. 353 /// \param AddrSpace address space of pointee in source language. getNullPointerValue(LangAS AddrSpace)354 virtual uint64_t getNullPointerValue(LangAS AddrSpace) const { return 0; } 355 356 /// Return the size of '_Bool' and C++ 'bool' for this target, in bits. getBoolWidth()357 unsigned getBoolWidth() const { return BoolWidth; } 358 359 /// Return the alignment of '_Bool' and C++ 'bool' for this target. getBoolAlign()360 unsigned getBoolAlign() const { return BoolAlign; } 361 getCharWidth()362 unsigned getCharWidth() const { return 8; } // FIXME getCharAlign()363 unsigned getCharAlign() const { return 8; } // FIXME 364 365 /// Return the size of 'signed short' and 'unsigned short' for this 366 /// target, in bits. getShortWidth()367 unsigned getShortWidth() const { return 16; } // FIXME 368 369 /// Return the alignment of 'signed short' and 'unsigned short' for 370 /// this target. getShortAlign()371 unsigned getShortAlign() const { return 16; } // FIXME 372 373 /// getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for 374 /// this target, in bits. getIntWidth()375 unsigned getIntWidth() const { return IntWidth; } getIntAlign()376 unsigned getIntAlign() const { return IntAlign; } 377 378 /// getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' 379 /// for this target, in bits. getLongWidth()380 unsigned getLongWidth() const { return LongWidth; } getLongAlign()381 unsigned getLongAlign() const { return LongAlign; } 382 383 /// getLongLongWidth/Align - Return the size of 'signed long long' and 384 /// 'unsigned long long' for this target, in bits. getLongLongWidth()385 unsigned getLongLongWidth() const { return LongLongWidth; } getLongLongAlign()386 unsigned getLongLongAlign() const { return LongLongAlign; } 387 388 /// getShortAccumWidth/Align - Return the size of 'signed short _Accum' and 389 /// 'unsigned short _Accum' for this target, in bits. getShortAccumWidth()390 unsigned getShortAccumWidth() const { return ShortAccumWidth; } getShortAccumAlign()391 unsigned getShortAccumAlign() const { return ShortAccumAlign; } 392 393 /// getAccumWidth/Align - Return the size of 'signed _Accum' and 394 /// 'unsigned _Accum' for this target, in bits. getAccumWidth()395 unsigned getAccumWidth() const { return AccumWidth; } getAccumAlign()396 unsigned getAccumAlign() const { return AccumAlign; } 397 398 /// getLongAccumWidth/Align - Return the size of 'signed long _Accum' and 399 /// 'unsigned long _Accum' for this target, in bits. getLongAccumWidth()400 unsigned getLongAccumWidth() const { return LongAccumWidth; } getLongAccumAlign()401 unsigned getLongAccumAlign() const { return LongAccumAlign; } 402 403 /// getShortFractWidth/Align - Return the size of 'signed short _Fract' and 404 /// 'unsigned short _Fract' for this target, in bits. getShortFractWidth()405 unsigned getShortFractWidth() const { return ShortFractWidth; } getShortFractAlign()406 unsigned getShortFractAlign() const { return ShortFractAlign; } 407 408 /// getFractWidth/Align - Return the size of 'signed _Fract' and 409 /// 'unsigned _Fract' for this target, in bits. getFractWidth()410 unsigned getFractWidth() const { return FractWidth; } getFractAlign()411 unsigned getFractAlign() const { return FractAlign; } 412 413 /// getLongFractWidth/Align - Return the size of 'signed long _Fract' and 414 /// 'unsigned long _Fract' for this target, in bits. getLongFractWidth()415 unsigned getLongFractWidth() const { return LongFractWidth; } getLongFractAlign()416 unsigned getLongFractAlign() const { return LongFractAlign; } 417 418 /// getShortAccumScale/IBits - Return the number of fractional/integral bits 419 /// in a 'signed short _Accum' type. getShortAccumScale()420 unsigned getShortAccumScale() const { return ShortAccumScale; } getShortAccumIBits()421 unsigned getShortAccumIBits() const { 422 return ShortAccumWidth - ShortAccumScale - 1; 423 } 424 425 /// getAccumScale/IBits - Return the number of fractional/integral bits 426 /// in a 'signed _Accum' type. getAccumScale()427 unsigned getAccumScale() const { return AccumScale; } getAccumIBits()428 unsigned getAccumIBits() const { return AccumWidth - AccumScale - 1; } 429 430 /// getLongAccumScale/IBits - Return the number of fractional/integral bits 431 /// in a 'signed long _Accum' type. getLongAccumScale()432 unsigned getLongAccumScale() const { return LongAccumScale; } getLongAccumIBits()433 unsigned getLongAccumIBits() const { 434 return LongAccumWidth - LongAccumScale - 1; 435 } 436 437 /// getUnsignedShortAccumScale/IBits - Return the number of 438 /// fractional/integral bits in a 'unsigned short _Accum' type. getUnsignedShortAccumScale()439 unsigned getUnsignedShortAccumScale() const { 440 return PaddingOnUnsignedFixedPoint ? ShortAccumScale : ShortAccumScale + 1; 441 } getUnsignedShortAccumIBits()442 unsigned getUnsignedShortAccumIBits() const { 443 return PaddingOnUnsignedFixedPoint 444 ? getShortAccumIBits() 445 : ShortAccumWidth - getUnsignedShortAccumScale(); 446 } 447 448 /// getUnsignedAccumScale/IBits - Return the number of fractional/integral 449 /// bits in a 'unsigned _Accum' type. getUnsignedAccumScale()450 unsigned getUnsignedAccumScale() const { 451 return PaddingOnUnsignedFixedPoint ? AccumScale : AccumScale + 1; 452 } getUnsignedAccumIBits()453 unsigned getUnsignedAccumIBits() const { 454 return PaddingOnUnsignedFixedPoint ? getAccumIBits() 455 : AccumWidth - getUnsignedAccumScale(); 456 } 457 458 /// getUnsignedLongAccumScale/IBits - Return the number of fractional/integral 459 /// bits in a 'unsigned long _Accum' type. getUnsignedLongAccumScale()460 unsigned getUnsignedLongAccumScale() const { 461 return PaddingOnUnsignedFixedPoint ? LongAccumScale : LongAccumScale + 1; 462 } getUnsignedLongAccumIBits()463 unsigned getUnsignedLongAccumIBits() const { 464 return PaddingOnUnsignedFixedPoint 465 ? getLongAccumIBits() 466 : LongAccumWidth - getUnsignedLongAccumScale(); 467 } 468 469 /// getShortFractScale - Return the number of fractional bits 470 /// in a 'signed short _Fract' type. getShortFractScale()471 unsigned getShortFractScale() const { return ShortFractWidth - 1; } 472 473 /// getFractScale - Return the number of fractional bits 474 /// in a 'signed _Fract' type. getFractScale()475 unsigned getFractScale() const { return FractWidth - 1; } 476 477 /// getLongFractScale - Return the number of fractional bits 478 /// in a 'signed long _Fract' type. getLongFractScale()479 unsigned getLongFractScale() const { return LongFractWidth - 1; } 480 481 /// getUnsignedShortFractScale - Return the number of fractional bits 482 /// in a 'unsigned short _Fract' type. getUnsignedShortFractScale()483 unsigned getUnsignedShortFractScale() const { 484 return PaddingOnUnsignedFixedPoint ? getShortFractScale() 485 : getShortFractScale() + 1; 486 } 487 488 /// getUnsignedFractScale - Return the number of fractional bits 489 /// in a 'unsigned _Fract' type. getUnsignedFractScale()490 unsigned getUnsignedFractScale() const { 491 return PaddingOnUnsignedFixedPoint ? getFractScale() : getFractScale() + 1; 492 } 493 494 /// getUnsignedLongFractScale - Return the number of fractional bits 495 /// in a 'unsigned long _Fract' type. getUnsignedLongFractScale()496 unsigned getUnsignedLongFractScale() const { 497 return PaddingOnUnsignedFixedPoint ? getLongFractScale() 498 : getLongFractScale() + 1; 499 } 500 501 /// Determine whether the __int128 type is supported on this target. hasInt128Type()502 virtual bool hasInt128Type() const { 503 return (getPointerWidth(0) >= 64) || getTargetOpts().ForceEnableInt128; 504 } // FIXME 505 506 /// Determine whether _Float16 is supported on this target. hasLegalHalfType()507 virtual bool hasLegalHalfType() const { return HasLegalHalfType; } 508 509 /// Determine whether the __float128 type is supported on this target. hasFloat128Type()510 virtual bool hasFloat128Type() const { return HasFloat128; } 511 512 /// Return the alignment that is suitable for storing any 513 /// object with a fundamental alignment requirement. getSuitableAlign()514 unsigned getSuitableAlign() const { return SuitableAlign; } 515 516 /// Return the default alignment for __attribute__((aligned)) on 517 /// this target, to be used if no alignment value is specified. getDefaultAlignForAttributeAligned()518 unsigned getDefaultAlignForAttributeAligned() const { 519 return DefaultAlignForAttributeAligned; 520 } 521 522 /// getMinGlobalAlign - Return the minimum alignment of a global variable, 523 /// unless its alignment is explicitly reduced via attributes. getMinGlobalAlign()524 unsigned getMinGlobalAlign() const { return MinGlobalAlign; } 525 526 /// Return the largest alignment for which a suitably-sized allocation with 527 /// '::operator new(size_t)' is guaranteed to produce a correctly-aligned 528 /// pointer. getNewAlign()529 unsigned getNewAlign() const { 530 return NewAlign ? NewAlign : std::max(LongDoubleAlign, LongLongAlign); 531 } 532 533 /// getWCharWidth/Align - Return the size of 'wchar_t' for this target, in 534 /// bits. getWCharWidth()535 unsigned getWCharWidth() const { return getTypeWidth(WCharType); } getWCharAlign()536 unsigned getWCharAlign() const { return getTypeAlign(WCharType); } 537 538 /// getChar16Width/Align - Return the size of 'char16_t' for this target, in 539 /// bits. getChar16Width()540 unsigned getChar16Width() const { return getTypeWidth(Char16Type); } getChar16Align()541 unsigned getChar16Align() const { return getTypeAlign(Char16Type); } 542 543 /// getChar32Width/Align - Return the size of 'char32_t' for this target, in 544 /// bits. getChar32Width()545 unsigned getChar32Width() const { return getTypeWidth(Char32Type); } getChar32Align()546 unsigned getChar32Align() const { return getTypeAlign(Char32Type); } 547 548 /// getHalfWidth/Align/Format - Return the size/align/format of 'half'. getHalfWidth()549 unsigned getHalfWidth() const { return HalfWidth; } getHalfAlign()550 unsigned getHalfAlign() const { return HalfAlign; } getHalfFormat()551 const llvm::fltSemantics &getHalfFormat() const { return *HalfFormat; } 552 553 /// getFloatWidth/Align/Format - Return the size/align/format of 'float'. getFloatWidth()554 unsigned getFloatWidth() const { return FloatWidth; } getFloatAlign()555 unsigned getFloatAlign() const { return FloatAlign; } getFloatFormat()556 const llvm::fltSemantics &getFloatFormat() const { return *FloatFormat; } 557 558 /// getDoubleWidth/Align/Format - Return the size/align/format of 'double'. getDoubleWidth()559 unsigned getDoubleWidth() const { return DoubleWidth; } getDoubleAlign()560 unsigned getDoubleAlign() const { return DoubleAlign; } getDoubleFormat()561 const llvm::fltSemantics &getDoubleFormat() const { return *DoubleFormat; } 562 563 /// getLongDoubleWidth/Align/Format - Return the size/align/format of 'long 564 /// double'. getLongDoubleWidth()565 unsigned getLongDoubleWidth() const { return LongDoubleWidth; } getLongDoubleAlign()566 unsigned getLongDoubleAlign() const { return LongDoubleAlign; } getLongDoubleFormat()567 const llvm::fltSemantics &getLongDoubleFormat() const { 568 return *LongDoubleFormat; 569 } 570 571 /// getFloat128Width/Align/Format - Return the size/align/format of 572 /// '__float128'. getFloat128Width()573 unsigned getFloat128Width() const { return 128; } getFloat128Align()574 unsigned getFloat128Align() const { return Float128Align; } getFloat128Format()575 const llvm::fltSemantics &getFloat128Format() const { 576 return *Float128Format; 577 } 578 579 /// Return true if the 'long double' type should be mangled like 580 /// __float128. useFloat128ManglingForLongDouble()581 virtual bool useFloat128ManglingForLongDouble() const { return false; } 582 583 /// Return the value for the C99 FLT_EVAL_METHOD macro. getFloatEvalMethod()584 virtual unsigned getFloatEvalMethod() const { return 0; } 585 586 // getLargeArrayMinWidth/Align - Return the minimum array size that is 587 // 'large' and its alignment. getLargeArrayMinWidth()588 unsigned getLargeArrayMinWidth() const { return LargeArrayMinWidth; } getLargeArrayAlign()589 unsigned getLargeArrayAlign() const { return LargeArrayAlign; } 590 591 /// Return the maximum width lock-free atomic operation which will 592 /// ever be supported for the given target getMaxAtomicPromoteWidth()593 unsigned getMaxAtomicPromoteWidth() const { return MaxAtomicPromoteWidth; } 594 /// Return the maximum width lock-free atomic operation which can be 595 /// inlined given the supported features of the given target. getMaxAtomicInlineWidth()596 unsigned getMaxAtomicInlineWidth() const { return MaxAtomicInlineWidth; } 597 /// Set the maximum inline or promote width lock-free atomic operation 598 /// for the given target. setMaxAtomicWidth()599 virtual void setMaxAtomicWidth() {} 600 /// Returns true if the given target supports lock-free atomic 601 /// operations at the specified width and alignment. hasBuiltinAtomic(uint64_t AtomicSizeInBits,uint64_t AlignmentInBits)602 virtual bool hasBuiltinAtomic(uint64_t AtomicSizeInBits, 603 uint64_t AlignmentInBits) const { 604 return AtomicSizeInBits <= AlignmentInBits && 605 AtomicSizeInBits <= getMaxAtomicInlineWidth() && 606 (AtomicSizeInBits <= getCharWidth() || 607 llvm::isPowerOf2_64(AtomicSizeInBits / getCharWidth())); 608 } 609 610 /// Return the maximum vector alignment supported for the given target. getMaxVectorAlign()611 unsigned getMaxVectorAlign() const { return MaxVectorAlign; } 612 /// Return default simd alignment for the given target. Generally, this 613 /// value is type-specific, but this alignment can be used for most of the 614 /// types for the given target. getSimdDefaultAlign()615 unsigned getSimdDefaultAlign() const { return SimdDefaultAlign; } 616 617 /// Return the size of intmax_t and uintmax_t for this target, in bits. getIntMaxTWidth()618 unsigned getIntMaxTWidth() const { 619 return getTypeWidth(IntMaxType); 620 } 621 622 // Return the size of unwind_word for this target. getUnwindWordWidth()623 virtual unsigned getUnwindWordWidth() const { return getPointerWidth(0); } 624 625 /// Return the "preferred" register width on this target. getRegisterWidth()626 virtual unsigned getRegisterWidth() const { 627 // Currently we assume the register width on the target matches the pointer 628 // width, we can introduce a new variable for this if/when some target wants 629 // it. 630 return PointerWidth; 631 } 632 633 /// Returns the name of the mcount instrumentation function. getMCountName()634 const char *getMCountName() const { 635 return MCountName; 636 } 637 638 /// Check if the Objective-C built-in boolean type should be signed 639 /// char. 640 /// 641 /// Otherwise, if this returns false, the normal built-in boolean type 642 /// should also be used for Objective-C. useSignedCharForObjCBool()643 bool useSignedCharForObjCBool() const { 644 return UseSignedCharForObjCBool; 645 } noSignedCharForObjCBool()646 void noSignedCharForObjCBool() { 647 UseSignedCharForObjCBool = false; 648 } 649 650 /// Check whether the alignment of bit-field types is respected 651 /// when laying out structures. useBitFieldTypeAlignment()652 bool useBitFieldTypeAlignment() const { 653 return UseBitFieldTypeAlignment; 654 } 655 656 /// Check whether zero length bitfields should force alignment of 657 /// the next member. useZeroLengthBitfieldAlignment()658 bool useZeroLengthBitfieldAlignment() const { 659 return UseZeroLengthBitfieldAlignment; 660 } 661 662 /// Get the fixed alignment value in bits for a member that follows 663 /// a zero length bitfield. getZeroLengthBitfieldBoundary()664 unsigned getZeroLengthBitfieldBoundary() const { 665 return ZeroLengthBitfieldBoundary; 666 } 667 668 /// Check whether explicit bitfield alignment attributes should be 669 // honored, as in "__attribute__((aligned(2))) int b : 1;". useExplicitBitFieldAlignment()670 bool useExplicitBitFieldAlignment() const { 671 return UseExplicitBitFieldAlignment; 672 } 673 674 /// Check whether this target support '\#pragma options align=mac68k'. hasAlignMac68kSupport()675 bool hasAlignMac68kSupport() const { 676 return HasAlignMac68kSupport; 677 } 678 679 /// Return the user string for the specified integer type enum. 680 /// 681 /// For example, SignedShort -> "short". 682 static const char *getTypeName(IntType T); 683 684 /// Return the constant suffix for the specified integer type enum. 685 /// 686 /// For example, SignedLong -> "L". 687 const char *getTypeConstantSuffix(IntType T) const; 688 689 /// Return the printf format modifier for the specified 690 /// integer type enum. 691 /// 692 /// For example, SignedLong -> "l". 693 static const char *getTypeFormatModifier(IntType T); 694 695 /// Check whether the given real type should use the "fpret" flavor of 696 /// Objective-C message passing on this target. useObjCFPRetForRealType(RealType T)697 bool useObjCFPRetForRealType(RealType T) const { 698 return RealTypeUsesObjCFPRet & (1 << T); 699 } 700 701 /// Check whether _Complex long double should use the "fp2ret" flavor 702 /// of Objective-C message passing on this target. useObjCFP2RetForComplexLongDouble()703 bool useObjCFP2RetForComplexLongDouble() const { 704 return ComplexLongDoubleUsesFP2Ret; 705 } 706 707 /// Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used 708 /// to convert to and from __fp16. 709 /// FIXME: This function should be removed once all targets stop using the 710 /// conversion intrinsics. useFP16ConversionIntrinsics()711 virtual bool useFP16ConversionIntrinsics() const { 712 return true; 713 } 714 715 /// Specify if mangling based on address space map should be used or 716 /// not for language specific address spaces useAddressSpaceMapMangling()717 bool useAddressSpaceMapMangling() const { 718 return UseAddrSpaceMapMangling; 719 } 720 721 ///===---- Other target property query methods --------------------------===// 722 723 /// Appends the target-specific \#define values for this 724 /// target set to the specified buffer. 725 virtual void getTargetDefines(const LangOptions &Opts, 726 MacroBuilder &Builder) const = 0; 727 728 729 /// Return information about target-specific builtins for 730 /// the current primary target, and info about which builtins are non-portable 731 /// across the current set of primary and secondary targets. 732 virtual ArrayRef<Builtin::Info> getTargetBuiltins() const = 0; 733 734 /// The __builtin_clz* and __builtin_ctz* built-in 735 /// functions are specified to have undefined results for zero inputs, but 736 /// on targets that support these operations in a way that provides 737 /// well-defined results for zero without loss of performance, it is a good 738 /// idea to avoid optimizing based on that undef behavior. isCLZForZeroUndef()739 virtual bool isCLZForZeroUndef() const { return true; } 740 741 /// Returns the kind of __builtin_va_list type that should be used 742 /// with this target. 743 virtual BuiltinVaListKind getBuiltinVaListKind() const = 0; 744 745 /// Returns whether or not type \c __builtin_ms_va_list type is 746 /// available on this target. hasBuiltinMSVaList()747 bool hasBuiltinMSVaList() const { return HasBuiltinMSVaList; } 748 749 /// Returns true for RenderScript. isRenderScriptTarget()750 bool isRenderScriptTarget() const { return IsRenderScriptTarget; } 751 752 /// Returns whether the passed in string is a valid clobber in an 753 /// inline asm statement. 754 /// 755 /// This is used by Sema. 756 bool isValidClobber(StringRef Name) const; 757 758 /// Returns whether the passed in string is a valid register name 759 /// according to GCC. 760 /// 761 /// This is used by Sema for inline asm statements. 762 virtual bool isValidGCCRegisterName(StringRef Name) const; 763 764 /// Returns the "normalized" GCC register name. 765 /// 766 /// ReturnCannonical true will return the register name without any additions 767 /// such as "{}" or "%" in it's canonical form, for example: 768 /// ReturnCanonical = true and Name = "rax", will return "ax". 769 StringRef getNormalizedGCCRegisterName(StringRef Name, 770 bool ReturnCanonical = false) const; 771 772 /// Extracts a register from the passed constraint (if it is a 773 /// single-register constraint) and the asm label expression related to a 774 /// variable in the input or output list of an inline asm statement. 775 /// 776 /// This function is used by Sema in order to diagnose conflicts between 777 /// the clobber list and the input/output lists. getConstraintRegister(StringRef Constraint,StringRef Expression)778 virtual StringRef getConstraintRegister(StringRef Constraint, 779 StringRef Expression) const { 780 return ""; 781 } 782 783 struct ConstraintInfo { 784 enum { 785 CI_None = 0x00, 786 CI_AllowsMemory = 0x01, 787 CI_AllowsRegister = 0x02, 788 CI_ReadWrite = 0x04, // "+r" output constraint (read and write). 789 CI_HasMatchingInput = 0x08, // This output operand has a matching input. 790 CI_ImmediateConstant = 0x10, // This operand must be an immediate constant 791 CI_EarlyClobber = 0x20, // "&" output constraint (early clobber). 792 }; 793 unsigned Flags; 794 int TiedOperand; 795 struct { 796 int Min; 797 int Max; 798 } ImmRange; 799 llvm::SmallSet<int, 4> ImmSet; 800 801 std::string ConstraintStr; // constraint: "=rm" 802 std::string Name; // Operand name: [foo] with no []'s. 803 public: ConstraintInfoConstraintInfo804 ConstraintInfo(StringRef ConstraintStr, StringRef Name) 805 : Flags(0), TiedOperand(-1), ConstraintStr(ConstraintStr.str()), 806 Name(Name.str()) { 807 ImmRange.Min = ImmRange.Max = 0; 808 } 809 getConstraintStrConstraintInfo810 const std::string &getConstraintStr() const { return ConstraintStr; } getNameConstraintInfo811 const std::string &getName() const { return Name; } isReadWriteConstraintInfo812 bool isReadWrite() const { return (Flags & CI_ReadWrite) != 0; } earlyClobberConstraintInfo813 bool earlyClobber() { return (Flags & CI_EarlyClobber) != 0; } allowsRegisterConstraintInfo814 bool allowsRegister() const { return (Flags & CI_AllowsRegister) != 0; } allowsMemoryConstraintInfo815 bool allowsMemory() const { return (Flags & CI_AllowsMemory) != 0; } 816 817 /// Return true if this output operand has a matching 818 /// (tied) input operand. hasMatchingInputConstraintInfo819 bool hasMatchingInput() const { return (Flags & CI_HasMatchingInput) != 0; } 820 821 /// Return true if this input operand is a matching 822 /// constraint that ties it to an output operand. 823 /// 824 /// If this returns true then getTiedOperand will indicate which output 825 /// operand this is tied to. hasTiedOperandConstraintInfo826 bool hasTiedOperand() const { return TiedOperand != -1; } getTiedOperandConstraintInfo827 unsigned getTiedOperand() const { 828 assert(hasTiedOperand() && "Has no tied operand!"); 829 return (unsigned)TiedOperand; 830 } 831 requiresImmediateConstantConstraintInfo832 bool requiresImmediateConstant() const { 833 return (Flags & CI_ImmediateConstant) != 0; 834 } isValidAsmImmediateConstraintInfo835 bool isValidAsmImmediate(const llvm::APInt &Value) const { 836 return (Value.sge(ImmRange.Min) && Value.sle(ImmRange.Max)) || 837 ImmSet.count(Value.getZExtValue()) != 0; 838 } 839 setIsReadWriteConstraintInfo840 void setIsReadWrite() { Flags |= CI_ReadWrite; } setEarlyClobberConstraintInfo841 void setEarlyClobber() { Flags |= CI_EarlyClobber; } setAllowsMemoryConstraintInfo842 void setAllowsMemory() { Flags |= CI_AllowsMemory; } setAllowsRegisterConstraintInfo843 void setAllowsRegister() { Flags |= CI_AllowsRegister; } setHasMatchingInputConstraintInfo844 void setHasMatchingInput() { Flags |= CI_HasMatchingInput; } setRequiresImmediateConstraintInfo845 void setRequiresImmediate(int Min, int Max) { 846 Flags |= CI_ImmediateConstant; 847 ImmRange.Min = Min; 848 ImmRange.Max = Max; 849 } setRequiresImmediateConstraintInfo850 void setRequiresImmediate(llvm::ArrayRef<int> Exacts) { 851 Flags |= CI_ImmediateConstant; 852 for (int Exact : Exacts) 853 ImmSet.insert(Exact); 854 } setRequiresImmediateConstraintInfo855 void setRequiresImmediate(int Exact) { 856 Flags |= CI_ImmediateConstant; 857 ImmSet.insert(Exact); 858 } setRequiresImmediateConstraintInfo859 void setRequiresImmediate() { 860 Flags |= CI_ImmediateConstant; 861 ImmRange.Min = INT_MIN; 862 ImmRange.Max = INT_MAX; 863 } 864 865 /// Indicate that this is an input operand that is tied to 866 /// the specified output operand. 867 /// 868 /// Copy over the various constraint information from the output. setTiedOperandConstraintInfo869 void setTiedOperand(unsigned N, ConstraintInfo &Output) { 870 Output.setHasMatchingInput(); 871 Flags = Output.Flags; 872 TiedOperand = N; 873 // Don't copy Name or constraint string. 874 } 875 }; 876 877 /// Validate register name used for global register variables. 878 /// 879 /// This function returns true if the register passed in RegName can be used 880 /// for global register variables on this target. In addition, it returns 881 /// true in HasSizeMismatch if the size of the register doesn't match the 882 /// variable size passed in RegSize. validateGlobalRegisterVariable(StringRef RegName,unsigned RegSize,bool & HasSizeMismatch)883 virtual bool validateGlobalRegisterVariable(StringRef RegName, 884 unsigned RegSize, 885 bool &HasSizeMismatch) const { 886 HasSizeMismatch = false; 887 return true; 888 } 889 890 // validateOutputConstraint, validateInputConstraint - Checks that 891 // a constraint is valid and provides information about it. 892 // FIXME: These should return a real error instead of just true/false. 893 bool validateOutputConstraint(ConstraintInfo &Info) const; 894 bool validateInputConstraint(MutableArrayRef<ConstraintInfo> OutputConstraints, 895 ConstraintInfo &info) const; 896 validateOutputSize(StringRef,unsigned)897 virtual bool validateOutputSize(StringRef /*Constraint*/, 898 unsigned /*Size*/) const { 899 return true; 900 } 901 validateInputSize(StringRef,unsigned)902 virtual bool validateInputSize(StringRef /*Constraint*/, 903 unsigned /*Size*/) const { 904 return true; 905 } 906 virtual bool validateConstraintModifier(StringRef,char,unsigned,std::string &)907 validateConstraintModifier(StringRef /*Constraint*/, 908 char /*Modifier*/, 909 unsigned /*Size*/, 910 std::string &/*SuggestedModifier*/) const { 911 return true; 912 } 913 virtual bool 914 validateAsmConstraint(const char *&Name, 915 TargetInfo::ConstraintInfo &info) const = 0; 916 917 bool resolveSymbolicName(const char *&Name, 918 ArrayRef<ConstraintInfo> OutputConstraints, 919 unsigned &Index) const; 920 921 // Constraint parm will be left pointing at the last character of 922 // the constraint. In practice, it won't be changed unless the 923 // constraint is longer than one character. convertConstraint(const char * & Constraint)924 virtual std::string convertConstraint(const char *&Constraint) const { 925 // 'p' defaults to 'r', but can be overridden by targets. 926 if (*Constraint == 'p') 927 return std::string("r"); 928 return std::string(1, *Constraint); 929 } 930 931 /// Returns a string of target-specific clobbers, in LLVM format. 932 virtual const char *getClobbers() const = 0; 933 934 /// Returns true if NaN encoding is IEEE 754-2008. 935 /// Only MIPS allows a different encoding. isNan2008()936 virtual bool isNan2008() const { 937 return true; 938 } 939 940 /// Returns the target triple of the primary target. getTriple()941 const llvm::Triple &getTriple() const { 942 return Triple; 943 } 944 getDataLayout()945 const llvm::DataLayout &getDataLayout() const { 946 assert(DataLayout && "Uninitialized DataLayout!"); 947 return *DataLayout; 948 } 949 950 struct GCCRegAlias { 951 const char * const Aliases[5]; 952 const char * const Register; 953 }; 954 955 struct AddlRegName { 956 const char * const Names[5]; 957 const unsigned RegNum; 958 }; 959 960 /// Does this target support "protected" visibility? 961 /// 962 /// Any target which dynamic libraries will naturally support 963 /// something like "default" (meaning that the symbol is visible 964 /// outside this shared object) and "hidden" (meaning that it isn't) 965 /// visibilities, but "protected" is really an ELF-specific concept 966 /// with weird semantics designed around the convenience of dynamic 967 /// linker implementations. Which is not to suggest that there's 968 /// consistent target-independent semantics for "default" visibility 969 /// either; the entire thing is pretty badly mangled. hasProtectedVisibility()970 virtual bool hasProtectedVisibility() const { return true; } 971 972 /// An optional hook that targets can implement to perform semantic 973 /// checking on attribute((section("foo"))) specifiers. 974 /// 975 /// In this case, "foo" is passed in to be checked. If the section 976 /// specifier is invalid, the backend should return a non-empty string 977 /// that indicates the problem. 978 /// 979 /// This hook is a simple quality of implementation feature to catch errors 980 /// and give good diagnostics in cases when the assembler or code generator 981 /// would otherwise reject the section specifier. 982 /// isValidSectionSpecifier(StringRef SR)983 virtual std::string isValidSectionSpecifier(StringRef SR) const { 984 return ""; 985 } 986 987 /// Set forced language options. 988 /// 989 /// Apply changes to the target information with respect to certain 990 /// language options which change the target configuration and adjust 991 /// the language based on the target options where applicable. 992 virtual void adjust(LangOptions &Opts); 993 994 /// Adjust target options based on codegen options. adjustTargetOptions(const CodeGenOptions & CGOpts,TargetOptions & TargetOpts)995 virtual void adjustTargetOptions(const CodeGenOptions &CGOpts, 996 TargetOptions &TargetOpts) const {} 997 998 /// Initialize the map with the default set of target features for the 999 /// CPU this should include all legal feature strings on the target. 1000 /// 1001 /// \return False on error (invalid features). 1002 virtual bool initFeatureMap(llvm::StringMap<bool> &Features, 1003 DiagnosticsEngine &Diags, StringRef CPU, 1004 const std::vector<std::string> &FeatureVec) const; 1005 1006 /// Get the ABI currently in use. getABI()1007 virtual StringRef getABI() const { return StringRef(); } 1008 1009 /// Get the C++ ABI currently in use. getCXXABI()1010 TargetCXXABI getCXXABI() const { 1011 return TheCXXABI; 1012 } 1013 1014 /// Target the specified CPU. 1015 /// 1016 /// \return False on error (invalid CPU name). setCPU(const std::string & Name)1017 virtual bool setCPU(const std::string &Name) { 1018 return false; 1019 } 1020 1021 /// Fill a SmallVectorImpl with the valid values to setCPU. fillValidCPUList(SmallVectorImpl<StringRef> & Values)1022 virtual void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {} 1023 1024 /// brief Determine whether this TargetInfo supports the given CPU name. isValidCPUName(StringRef Name)1025 virtual bool isValidCPUName(StringRef Name) const { 1026 return true; 1027 } 1028 1029 /// Use the specified ABI. 1030 /// 1031 /// \return False on error (invalid ABI name). setABI(const std::string & Name)1032 virtual bool setABI(const std::string &Name) { 1033 return false; 1034 } 1035 1036 /// Use the specified unit for FP math. 1037 /// 1038 /// \return False on error (invalid unit name). setFPMath(StringRef Name)1039 virtual bool setFPMath(StringRef Name) { 1040 return false; 1041 } 1042 1043 /// Enable or disable a specific target feature; 1044 /// the feature name must be valid. setFeatureEnabled(llvm::StringMap<bool> & Features,StringRef Name,bool Enabled)1045 virtual void setFeatureEnabled(llvm::StringMap<bool> &Features, 1046 StringRef Name, 1047 bool Enabled) const { 1048 Features[Name] = Enabled; 1049 } 1050 1051 /// Determine whether this TargetInfo supports the given feature. isValidFeatureName(StringRef Feature)1052 virtual bool isValidFeatureName(StringRef Feature) const { 1053 return true; 1054 } 1055 1056 /// Perform initialization based on the user configured 1057 /// set of features (e.g., +sse4). 1058 /// 1059 /// The list is guaranteed to have at most one entry per feature. 1060 /// 1061 /// The target may modify the features list, to change which options are 1062 /// passed onwards to the backend. 1063 /// FIXME: This part should be fixed so that we can change handleTargetFeatures 1064 /// to merely a TargetInfo initialization routine. 1065 /// 1066 /// \return False on error. handleTargetFeatures(std::vector<std::string> & Features,DiagnosticsEngine & Diags)1067 virtual bool handleTargetFeatures(std::vector<std::string> &Features, 1068 DiagnosticsEngine &Diags) { 1069 return true; 1070 } 1071 1072 /// Determine whether the given target has the given feature. hasFeature(StringRef Feature)1073 virtual bool hasFeature(StringRef Feature) const { 1074 return false; 1075 } 1076 1077 /// Identify whether this taret supports multiversioning of functions, 1078 /// which requires support for cpu_supports and cpu_is functionality. supportsMultiVersioning()1079 virtual bool supportsMultiVersioning() const { return false; } 1080 1081 // Validate the contents of the __builtin_cpu_supports(const char*) 1082 // argument. validateCpuSupports(StringRef Name)1083 virtual bool validateCpuSupports(StringRef Name) const { return false; } 1084 1085 // Return the target-specific priority for features/cpus/vendors so 1086 // that they can be properly sorted for checking. multiVersionSortPriority(StringRef Name)1087 virtual unsigned multiVersionSortPriority(StringRef Name) const { 1088 return 0; 1089 } 1090 1091 // Validate the contents of the __builtin_cpu_is(const char*) 1092 // argument. validateCpuIs(StringRef Name)1093 virtual bool validateCpuIs(StringRef Name) const { return false; } 1094 1095 // Validate a cpu_dispatch/cpu_specific CPU option, which is a different list 1096 // from cpu_is, since it checks via features rather than CPUs directly. validateCPUSpecificCPUDispatch(StringRef Name)1097 virtual bool validateCPUSpecificCPUDispatch(StringRef Name) const { 1098 return false; 1099 } 1100 1101 // Get the character to be added for mangling purposes for cpu_specific. CPUSpecificManglingCharacter(StringRef Name)1102 virtual char CPUSpecificManglingCharacter(StringRef Name) const { 1103 llvm_unreachable( 1104 "cpu_specific Multiversioning not implemented on this target"); 1105 } 1106 1107 // Get a list of the features that make up the CPU option for 1108 // cpu_specific/cpu_dispatch so that it can be passed to llvm as optimization 1109 // options. getCPUSpecificCPUDispatchFeatures(StringRef Name,llvm::SmallVectorImpl<StringRef> & Features)1110 virtual void getCPUSpecificCPUDispatchFeatures( 1111 StringRef Name, llvm::SmallVectorImpl<StringRef> &Features) const { 1112 llvm_unreachable( 1113 "cpu_specific Multiversioning not implemented on this target"); 1114 } 1115 1116 // Returns maximal number of args passed in registers. getRegParmMax()1117 unsigned getRegParmMax() const { 1118 assert(RegParmMax < 7 && "RegParmMax value is larger than AST can handle"); 1119 return RegParmMax; 1120 } 1121 1122 /// Whether the target supports thread-local storage. isTLSSupported()1123 bool isTLSSupported() const { 1124 return TLSSupported; 1125 } 1126 1127 /// Return the maximum alignment (in bits) of a TLS variable 1128 /// 1129 /// Gets the maximum alignment (in bits) of a TLS variable on this target. 1130 /// Returns zero if there is no such constraint. getMaxTLSAlign()1131 unsigned short getMaxTLSAlign() const { 1132 return MaxTLSAlign; 1133 } 1134 1135 /// Whether target supports variable-length arrays. isVLASupported()1136 bool isVLASupported() const { return VLASupported; } 1137 1138 /// Whether the target supports SEH __try. isSEHTrySupported()1139 bool isSEHTrySupported() const { 1140 return getTriple().isOSWindows() && 1141 (getTriple().getArch() == llvm::Triple::x86 || 1142 getTriple().getArch() == llvm::Triple::x86_64 || 1143 getTriple().getArch() == llvm::Triple::aarch64); 1144 } 1145 1146 /// Return true if {|} are normal characters in the asm string. 1147 /// 1148 /// If this returns false (the default), then {abc|xyz} is syntax 1149 /// that says that when compiling for asm variant #0, "abc" should be 1150 /// generated, but when compiling for asm variant #1, "xyz" should be 1151 /// generated. hasNoAsmVariants()1152 bool hasNoAsmVariants() const { 1153 return NoAsmVariants; 1154 } 1155 1156 /// Return the register number that __builtin_eh_return_regno would 1157 /// return with the specified argument. 1158 /// This corresponds with TargetLowering's getExceptionPointerRegister 1159 /// and getExceptionSelectorRegister in the backend. getEHDataRegisterNumber(unsigned RegNo)1160 virtual int getEHDataRegisterNumber(unsigned RegNo) const { 1161 return -1; 1162 } 1163 1164 /// Return the section to use for C++ static initialization functions. getStaticInitSectionSpecifier()1165 virtual const char *getStaticInitSectionSpecifier() const { 1166 return nullptr; 1167 } 1168 getAddressSpaceMap()1169 const LangASMap &getAddressSpaceMap() const { return *AddrSpaceMap; } 1170 1171 /// Return an AST address space which can be used opportunistically 1172 /// for constant global memory. It must be possible to convert pointers into 1173 /// this address space to LangAS::Default. If no such address space exists, 1174 /// this may return None, and such optimizations will be disabled. getConstantAddressSpace()1175 virtual llvm::Optional<LangAS> getConstantAddressSpace() const { 1176 return LangAS::Default; 1177 } 1178 1179 /// Retrieve the name of the platform as it is used in the 1180 /// availability attribute. getPlatformName()1181 StringRef getPlatformName() const { return PlatformName; } 1182 1183 /// Retrieve the minimum desired version of the platform, to 1184 /// which the program should be compiled. getPlatformMinVersion()1185 VersionTuple getPlatformMinVersion() const { return PlatformMinVersion; } 1186 isBigEndian()1187 bool isBigEndian() const { return BigEndian; } isLittleEndian()1188 bool isLittleEndian() const { return !BigEndian; } 1189 1190 enum CallingConvMethodType { 1191 CCMT_Unknown, 1192 CCMT_Member, 1193 CCMT_NonMember 1194 }; 1195 1196 /// Gets the default calling convention for the given target and 1197 /// declaration context. getDefaultCallingConv(CallingConvMethodType MT)1198 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const { 1199 // Not all targets will specify an explicit calling convention that we can 1200 // express. This will always do the right thing, even though it's not 1201 // an explicit calling convention. 1202 return CC_C; 1203 } 1204 1205 enum CallingConvCheckResult { 1206 CCCR_OK, 1207 CCCR_Warning, 1208 CCCR_Ignore, 1209 }; 1210 1211 /// Determines whether a given calling convention is valid for the 1212 /// target. A calling convention can either be accepted, produce a warning 1213 /// and be substituted with the default calling convention, or (someday) 1214 /// produce an error (such as using thiscall on a non-instance function). checkCallingConvention(CallingConv CC)1215 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const { 1216 switch (CC) { 1217 default: 1218 return CCCR_Warning; 1219 case CC_C: 1220 return CCCR_OK; 1221 } 1222 } 1223 1224 enum CallingConvKind { 1225 CCK_Default, 1226 CCK_ClangABI4OrPS4, 1227 CCK_MicrosoftWin64 1228 }; 1229 1230 virtual CallingConvKind getCallingConvKind(bool ClangABICompat4) const; 1231 1232 /// Controls if __builtin_longjmp / __builtin_setjmp can be lowered to 1233 /// llvm.eh.sjlj.longjmp / llvm.eh.sjlj.setjmp. hasSjLjLowering()1234 virtual bool hasSjLjLowering() const { 1235 return false; 1236 } 1237 1238 /// Check if the target supports CFProtection branch. 1239 virtual bool 1240 checkCFProtectionBranchSupported(DiagnosticsEngine &Diags) const; 1241 1242 /// Check if the target supports CFProtection branch. 1243 virtual bool 1244 checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const; 1245 1246 /// Whether target allows to overalign ABI-specified preferred alignment allowsLargerPreferedTypeAlignment()1247 virtual bool allowsLargerPreferedTypeAlignment() const { return true; } 1248 1249 /// Set supported OpenCL extensions and optional core features. setSupportedOpenCLOpts()1250 virtual void setSupportedOpenCLOpts() {} 1251 1252 /// Set supported OpenCL extensions as written on command line setOpenCLExtensionOpts()1253 virtual void setOpenCLExtensionOpts() { 1254 for (const auto &Ext : getTargetOpts().OpenCLExtensionsAsWritten) { 1255 getTargetOpts().SupportedOpenCLOptions.support(Ext); 1256 } 1257 } 1258 1259 /// Get supported OpenCL extensions and optional core features. getSupportedOpenCLOpts()1260 OpenCLOptions &getSupportedOpenCLOpts() { 1261 return getTargetOpts().SupportedOpenCLOptions; 1262 } 1263 1264 /// Get const supported OpenCL extensions and optional core features. getSupportedOpenCLOpts()1265 const OpenCLOptions &getSupportedOpenCLOpts() const { 1266 return getTargetOpts().SupportedOpenCLOptions; 1267 } 1268 1269 enum OpenCLTypeKind { 1270 OCLTK_Default, 1271 OCLTK_ClkEvent, 1272 OCLTK_Event, 1273 OCLTK_Image, 1274 OCLTK_Pipe, 1275 OCLTK_Queue, 1276 OCLTK_ReserveID, 1277 OCLTK_Sampler, 1278 }; 1279 1280 /// Get address space for OpenCL type. 1281 virtual LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const; 1282 1283 /// \returns Target specific vtbl ptr address space. getVtblPtrAddressSpace()1284 virtual unsigned getVtblPtrAddressSpace() const { 1285 return 0; 1286 } 1287 1288 /// \returns If a target requires an address within a target specific address 1289 /// space \p AddressSpace to be converted in order to be used, then return the 1290 /// corresponding target specific DWARF address space. 1291 /// 1292 /// \returns Otherwise return None and no conversion will be emitted in the 1293 /// DWARF. getDWARFAddressSpace(unsigned AddressSpace)1294 virtual Optional<unsigned> getDWARFAddressSpace(unsigned AddressSpace) const { 1295 return None; 1296 } 1297 1298 /// Check the target is valid after it is fully initialized. validateTarget(DiagnosticsEngine & Diags)1299 virtual bool validateTarget(DiagnosticsEngine &Diags) const { 1300 return true; 1301 } 1302 1303 protected: getPointerWidthV(unsigned AddrSpace)1304 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { 1305 return PointerWidth; 1306 } getPointerAlignV(unsigned AddrSpace)1307 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { 1308 return PointerAlign; 1309 } getPtrDiffTypeV(unsigned AddrSpace)1310 virtual enum IntType getPtrDiffTypeV(unsigned AddrSpace) const { 1311 return PtrDiffType; 1312 } 1313 virtual ArrayRef<const char *> getGCCRegNames() const = 0; 1314 virtual ArrayRef<GCCRegAlias> getGCCRegAliases() const = 0; getGCCAddlRegNames()1315 virtual ArrayRef<AddlRegName> getGCCAddlRegNames() const { 1316 return None; 1317 } 1318 1319 private: 1320 // Assert the values for the fractional and integral bits for each fixed point 1321 // type follow the restrictions given in clause 6.2.6.3 of N1169. 1322 void CheckFixedPointBits() const; 1323 }; 1324 1325 } // end namespace clang 1326 1327 #endif 1328