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