Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- TargetInfo.h - Expose information about the target -----*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// Defines the clang::TargetInfo interface.

///

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_BASIC_TARGETINFO_H

#define LLVM_CLANG_BASIC_TARGETINFO_H

#include "clang/Basic/AddressSpaces.h"

#include "clang/Basic/BitmaskEnum.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TargetCXXABI.h"

#include "clang/Basic/TargetOptions.h"

#include "llvm/ADT/APFloat.h"

#include "llvm/ADT/APInt.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/SmallSet.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/Triple.h"

#include "llvm/Frontend/OpenMP/OMPGridValues.h"

#include "llvm/IR/DerivedTypes.h"

#include "llvm/Support/DataTypes.h"

#include "llvm/Support/Error.h"

#include "llvm/Support/VersionTuple.h"

#include <cassert>

#include <optional>

#include <string>

#include <vector>

namespace llvm {

struct fltSemantics;

}

namespace clang {

class DiagnosticsEngine;

class LangOptions;

class CodeGenOptions;

class MacroBuilder;

/// Contains information gathered from parsing the contents of TargetAttr.

struct ParsedTargetAttr {

  std::vector<std::string> Features;

  StringRef CPU;

  StringRef Tune;

  StringRef BranchProtection;

  StringRef Duplicate;

  bool operator ==(const ParsedTargetAttr &Other) const {

    return Duplicate == Other.Duplicate && CPU == Other.CPU &&

           Tune == Other.Tune && BranchProtection == Other.BranchProtection &&

           Features == Other.Features;

  }

};

namespace Builtin { struct Info; }

enum class FloatModeKind {

  NoFloat = 0,

  Half = 1 << 0,

  Float = 1 << 1,

  Double = 1 << 2,

  LongDouble = 1 << 3,

  Float128 = 1 << 4,

  Ibm128 = 1 << 5,

  LLVM_MARK_AS_BITMASK_ENUM(Ibm128)

};

/// Fields controlling how types are laid out in memory; these may need to

/// be copied for targets like AMDGPU that base their ABIs on an auxiliary

/// CPU target.

struct TransferrableTargetInfo {

  unsigned char PointerWidth, PointerAlign;

  unsigned char BoolWidth, BoolAlign;

  unsigned char IntWidth, IntAlign;

  unsigned char HalfWidth, HalfAlign;

  unsigned char BFloat16Width, BFloat16Align;

  unsigned char FloatWidth, FloatAlign;

  unsigned char DoubleWidth, DoubleAlign;

  unsigned char LongDoubleWidth, LongDoubleAlign, Float128Align, Ibm128Align;

  unsigned char LargeArrayMinWidth, LargeArrayAlign;

  unsigned char LongWidth, LongAlign;

  unsigned char LongLongWidth, LongLongAlign;

  unsigned char Int128Align;

  // Fixed point bit widths

  unsigned char ShortAccumWidth, ShortAccumAlign;

  unsigned char AccumWidth, AccumAlign;

  unsigned char LongAccumWidth, LongAccumAlign;

  unsigned char ShortFractWidth, ShortFractAlign;

  unsigned char FractWidth, FractAlign;

  unsigned char LongFractWidth, LongFractAlign;

  // If true, unsigned fixed point types have the same number of fractional bits

  // as their signed counterparts, forcing the unsigned types to have one extra

  // bit of padding. Otherwise, unsigned fixed point types have

  // one more fractional bit than its corresponding signed type. This is false

  // by default.

  bool PaddingOnUnsignedFixedPoint;

  // Fixed point integral and fractional bit sizes

  // Saturated types share the same integral/fractional bits as their

  // corresponding unsaturated types.

  // For simplicity, the fractional bits in a _Fract type will be one less the

  // width of that _Fract type. This leaves all signed _Fract types having no

  // padding and unsigned _Fract types will only have 1 bit of padding after the

  // sign if PaddingOnUnsignedFixedPoint is set.

  unsigned char ShortAccumScale;

  unsigned char AccumScale;

  unsigned char LongAccumScale;

  unsigned char DefaultAlignForAttributeAligned;

  unsigned char MinGlobalAlign;

  unsigned short SuitableAlign;

  unsigned short NewAlign;

  unsigned MaxVectorAlign;

  unsigned MaxTLSAlign;

  const llvm::fltSemantics *HalfFormat, *BFloat16Format, *FloatFormat,

      *DoubleFormat, *LongDoubleFormat, *Float128Format, *Ibm128Format;

  ///===---- Target Data Type Query Methods -------------------------------===//

  enum IntType {

    NoInt = 0,

    SignedChar,

    UnsignedChar,

    SignedShort,

    UnsignedShort,

    SignedInt,

    UnsignedInt,

    SignedLong,

    UnsignedLong,

    SignedLongLong,

    UnsignedLongLong

  };

protected:

  IntType SizeType, IntMaxType, PtrDiffType, IntPtrType, WCharType, WIntType,

      Char16Type, Char32Type, Int64Type, Int16Type, SigAtomicType,

      ProcessIDType;

  /// Whether Objective-C's built-in boolean type should be signed char.

  ///

  /// Otherwise, when this flag is not set, the normal built-in boolean type is

  /// used.

  unsigned UseSignedCharForObjCBool : 1;

  /// Control whether the alignment of bit-field types is respected when laying

  /// out structures. If true, then the alignment of the bit-field type will be

  /// used to (a) impact the alignment of the containing structure, and (b)

  /// ensure that the individual bit-field will not straddle an alignment

  /// boundary.

  unsigned UseBitFieldTypeAlignment : 1;

  /// Whether zero length bitfields (e.g., int : 0;) force alignment of

  /// the next bitfield.

  ///

  /// If the alignment of the zero length bitfield is greater than the member

  /// that follows it, `bar', `bar' will be aligned as the type of the

  /// zero-length bitfield.

  unsigned UseZeroLengthBitfieldAlignment : 1;

  /// Whether zero length bitfield alignment is respected if they are the

  /// leading members.

  unsigned UseLeadingZeroLengthBitfield : 1;

  ///  Whether explicit bit field alignment attributes are honored.

  unsigned UseExplicitBitFieldAlignment : 1;

  /// If non-zero, specifies a fixed alignment value for bitfields that follow

  /// zero length bitfield, regardless of the zero length bitfield type.

  unsigned ZeroLengthBitfieldBoundary;

  /// If non-zero, specifies a maximum alignment to truncate alignment

  /// specified in the aligned attribute of a static variable to this value.

  unsigned MaxAlignedAttribute;

};

/// OpenCL type kinds.

enum OpenCLTypeKind : uint8_t {

  OCLTK_Default,

  OCLTK_ClkEvent,

  OCLTK_Event,

  OCLTK_Image,

  OCLTK_Pipe,

  OCLTK_Queue,

  OCLTK_ReserveID,

  OCLTK_Sampler,

};

/// Exposes information about the current target.

///

class TargetInfo : public virtual TransferrableTargetInfo,

                   public RefCountedBase<TargetInfo> {

  std::shared_ptr<TargetOptions> TargetOpts;

  llvm::Triple Triple;

protected:

  // Target values set by the ctor of the actual target implementation.  Default

  // values are specified by the TargetInfo constructor.

  bool BigEndian;

  bool TLSSupported;

  bool VLASupported;

  bool NoAsmVariants;  // True if {|} are normal characters.

  bool HasLegalHalfType; // True if the backend supports operations on the half

                         // LLVM IR type.

  bool HalfArgsAndReturns;

  bool HasFloat128;

  bool HasFloat16;

  bool HasBFloat16;

  bool HasIbm128;

  bool HasLongDouble;

  bool HasFPReturn;

  bool HasStrictFP;

  unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;

  unsigned short SimdDefaultAlign;

  std::string DataLayoutString;

  const char *UserLabelPrefix;

  const char *MCountName;

  unsigned char RegParmMax, SSERegParmMax;

  TargetCXXABI TheCXXABI;

  const LangASMap *AddrSpaceMap;

  mutable StringRef PlatformName;

  mutable VersionTuple PlatformMinVersion;

  unsigned HasAlignMac68kSupport : 1;

  unsigned RealTypeUsesObjCFPRetMask : llvm::BitWidth<FloatModeKind>;

  unsigned ComplexLongDoubleUsesFP2Ret : 1;

  unsigned HasBuiltinMSVaList : 1;

  unsigned IsRenderScriptTarget : 1;

  unsigned HasAArch64SVETypes : 1;

  unsigned HasRISCVVTypes : 1;

  unsigned AllowAMDGPUUnsafeFPAtomics : 1;

  unsigned ARMCDECoprocMask : 8;

  unsigned MaxOpenCLWorkGroupSize;

  std::optional<unsigned> MaxBitIntWidth;

  std::optional<llvm::Triple> DarwinTargetVariantTriple;

  // TargetInfo Constructor.  Default initializes all fields.

  TargetInfo(const llvm::Triple &T);

  // UserLabelPrefix must match DL's getGlobalPrefix() when interpreted

  // as a DataLayout object.

  void resetDataLayout(StringRef DL, const char *UserLabelPrefix = "");

public:

  /// Construct a target for the given options.

  ///

  /// \param Opts - The options to use to initialize the target. The target may

  /// modify the options to canonicalize the target feature information to match

  /// what the backend expects.

  static TargetInfo *

  CreateTargetInfo(DiagnosticsEngine &Diags,

                   const std::shared_ptr<TargetOptions> &Opts);

  virtual ~TargetInfo();

  /// Retrieve the target options.

  TargetOptions &getTargetOpts() const {

    assert(TargetOpts && "Missing target options");

    return *TargetOpts;

  }

  /// The different kinds of __builtin_va_list types defined by

  /// the target implementation.

  enum BuiltinVaListKind {

    /// typedef char* __builtin_va_list;

    CharPtrBuiltinVaList = 0,

    /// typedef void* __builtin_va_list;

    VoidPtrBuiltinVaList,

    /// __builtin_va_list as defined by the AArch64 ABI

    /// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055a/IHI0055A_aapcs64.pdf

    AArch64ABIBuiltinVaList,

    /// __builtin_va_list as defined by the PNaCl ABI:

    /// http://www.chromium.org/nativeclient/pnacl/bitcode-abi#TOC-Machine-Types

    PNaClABIBuiltinVaList,

    /// __builtin_va_list as defined by the Power ABI:

    /// https://www.power.org

    ///        /resources/downloads/Power-Arch-32-bit-ABI-supp-1.0-Embedded.pdf

    PowerABIBuiltinVaList,

    /// __builtin_va_list as defined by the x86-64 ABI:

    /// http://refspecs.linuxbase.org/elf/x86_64-abi-0.21.pdf

    X86_64ABIBuiltinVaList,

    /// __builtin_va_list as defined by ARM AAPCS ABI

    /// http://infocenter.arm.com

    //        /help/topic/com.arm.doc.ihi0042d/IHI0042D_aapcs.pdf

    AAPCSABIBuiltinVaList,

    // typedef struct __va_list_tag

    //   {

    //     long __gpr;

    //     long __fpr;

    //     void *__overflow_arg_area;

    //     void *__reg_save_area;

    //   } va_list[1];

    SystemZBuiltinVaList,

    // typedef struct __va_list_tag {

    //    void *__current_saved_reg_area_pointer;

    //    void *__saved_reg_area_end_pointer;

    //    void *__overflow_area_pointer;

    //} va_list;

    HexagonBuiltinVaList

  };

protected:

  /// Specify if mangling based on address space map should be used or

  /// not for language specific address spaces

  bool UseAddrSpaceMapMangling;

public:

  IntType getSizeType() const { return SizeType; }

  IntType getSignedSizeType() const {

    switch (SizeType) {

    case UnsignedShort:

      return SignedShort;

    case UnsignedInt:

      return SignedInt;

    case UnsignedLong:

      return SignedLong;

    case UnsignedLongLong:

      return SignedLongLong;

    default:

      llvm_unreachable("Invalid SizeType");

    }

  }

  IntType getIntMaxType() const { return IntMaxType; }

  IntType getUIntMaxType() const {

    return getCorrespondingUnsignedType(IntMaxType);

  }

  IntType getPtrDiffType(LangAS AddrSpace) const {

    return AddrSpace == LangAS::Default ? PtrDiffType

                                        : getPtrDiffTypeV(AddrSpace);

  }

  IntType getUnsignedPtrDiffType(LangAS AddrSpace) const {

    return getCorrespondingUnsignedType(getPtrDiffType(AddrSpace));

  }

  IntType getIntPtrType() const { return IntPtrType; }

  IntType getUIntPtrType() const {

    return getCorrespondingUnsignedType(IntPtrType);

  }

  IntType getWCharType() const { return WCharType; }

  IntType getWIntType() const { return WIntType; }

  IntType getChar16Type() const { return Char16Type; }

  IntType getChar32Type() const { return Char32Type; }

  IntType getInt64Type() const { return Int64Type; }

  IntType getUInt64Type() const {

    return getCorrespondingUnsignedType(Int64Type);

  }

  IntType getInt16Type() const { return Int16Type; }

  IntType getUInt16Type() const {

    return getCorrespondingUnsignedType(Int16Type);

  }

  IntType getSigAtomicType() const { return SigAtomicType; }

  IntType getProcessIDType() const { return ProcessIDType; }

  static IntType getCorrespondingUnsignedType(IntType T) {

    switch (T) {

    case SignedChar:

      return UnsignedChar;

    case SignedShort:

      return UnsignedShort;

    case SignedInt:

      return UnsignedInt;

    case SignedLong:

      return UnsignedLong;

    case SignedLongLong:

      return UnsignedLongLong;

    default:

      llvm_unreachable("Unexpected signed integer type");

    }

  }

  /// In the event this target uses the same number of fractional bits for its

  /// unsigned types as it does with its signed counterparts, there will be

  /// exactly one bit of padding.

  /// Return true if unsigned fixed point types have padding for this target.

  bool doUnsignedFixedPointTypesHavePadding() const {

    return PaddingOnUnsignedFixedPoint;

  }

  /// Return the width (in bits) of the specified integer type enum.

  ///

  /// For example, SignedInt -> getIntWidth().

  unsigned getTypeWidth(IntType T) const;

  /// Return integer type with specified width.

  virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const;

  /// Return the smallest integer type with at least the specified width.

  virtual IntType getLeastIntTypeByWidth(unsigned BitWidth,

                                         bool IsSigned) const;

  /// Return floating point type with specified width. On PPC, there are

  /// three possible types for 128-bit floating point: "PPC double-double",

  /// IEEE 754R quad precision, and "long double" (which under the covers

  /// is represented as one of those two). At this time, there is no support

  /// for an explicit "PPC double-double" type (i.e. __ibm128) so we only

  /// need to differentiate between "long double" and IEEE quad precision.

  FloatModeKind getRealTypeByWidth(unsigned BitWidth,

                                   FloatModeKind ExplicitType) const;

  /// Return the alignment (in bits) of the specified integer type enum.

  ///

  /// For example, SignedInt -> getIntAlign().

  unsigned getTypeAlign(IntType T) const;

  /// Returns true if the type is signed; false otherwise.

  static bool isTypeSigned(IntType T);

  /// Return the width of pointers on this target, for the

  /// specified address space.

  uint64_t getPointerWidth(LangAS AddrSpace) const {

    return AddrSpace == LangAS::Default ? PointerWidth

                                        : getPointerWidthV(AddrSpace);

  }

  uint64_t getPointerAlign(LangAS AddrSpace) const {

    return AddrSpace == LangAS::Default ? PointerAlign

                                        : getPointerAlignV(AddrSpace);

  }

  /// Return the maximum width of pointers on this target.

  virtual uint64_t getMaxPointerWidth() const {

    return PointerWidth;

  }

  /// Get integer value for null pointer.

  /// \param AddrSpace address space of pointee in source language.

  virtual uint64_t getNullPointerValue(LangAS AddrSpace) const { return 0; }

  /// Return the size of '_Bool' and C++ 'bool' for this target, in bits.

  unsigned getBoolWidth() const { return BoolWidth; }

  /// Return the alignment of '_Bool' and C++ 'bool' for this target.

  unsigned getBoolAlign() const { return BoolAlign; }

  unsigned getCharWidth() const { return 8; } // FIXME

  unsigned getCharAlign() const { return 8; } // FIXME

  /// Return the size of 'signed short' and 'unsigned short' for this

  /// target, in bits.

  unsigned getShortWidth() const { return 16; } // FIXME

  /// Return the alignment of 'signed short' and 'unsigned short' for

  /// this target.

  unsigned getShortAlign() const { return 16; } // FIXME

  /// getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for

  /// this target, in bits.

  unsigned getIntWidth() const { return IntWidth; }

  unsigned getIntAlign() const { return IntAlign; }

  /// getLongWidth/Align - Return the size of 'signed long' and 'unsigned long'

  /// for this target, in bits.

  unsigned getLongWidth() const { return LongWidth; }

  unsigned getLongAlign() const { return LongAlign; }

  /// getLongLongWidth/Align - Return the size of 'signed long long' and

  /// 'unsigned long long' for this target, in bits.

  unsigned getLongLongWidth() const { return LongLongWidth; }

  unsigned getLongLongAlign() const { return LongLongAlign; }

  /// getInt128Align() - Returns the alignment of Int128.

  unsigned getInt128Align() const { return Int128Align; }

  /// getShortAccumWidth/Align - Return the size of 'signed short _Accum' and

  /// 'unsigned short _Accum' for this target, in bits.

  unsigned getShortAccumWidth() const { return ShortAccumWidth; }

  unsigned getShortAccumAlign() const { return ShortAccumAlign; }

  /// getAccumWidth/Align - Return the size of 'signed _Accum' and

  /// 'unsigned _Accum' for this target, in bits.

  unsigned getAccumWidth() const { return AccumWidth; }

  unsigned getAccumAlign() const { return AccumAlign; }

  /// getLongAccumWidth/Align - Return the size of 'signed long _Accum' and

  /// 'unsigned long _Accum' for this target, in bits.

  unsigned getLongAccumWidth() const { return LongAccumWidth; }

  unsigned getLongAccumAlign() const { return LongAccumAlign; }

  /// getShortFractWidth/Align - Return the size of 'signed short _Fract' and

  /// 'unsigned short _Fract' for this target, in bits.

  unsigned getShortFractWidth() const { return ShortFractWidth; }

  unsigned getShortFractAlign() const { return ShortFractAlign; }

  /// getFractWidth/Align - Return the size of 'signed _Fract' and

  /// 'unsigned _Fract' for this target, in bits.

  unsigned getFractWidth() const { return FractWidth; }

  unsigned getFractAlign() const { return FractAlign; }

  /// getLongFractWidth/Align - Return the size of 'signed long _Fract' and

  /// 'unsigned long _Fract' for this target, in bits.

  unsigned getLongFractWidth() const { return LongFractWidth; }

  unsigned getLongFractAlign() const { return LongFractAlign; }

  /// getShortAccumScale/IBits - Return the number of fractional/integral bits

  /// in a 'signed short _Accum' type.

  unsigned getShortAccumScale() const { return ShortAccumScale; }

  unsigned getShortAccumIBits() const {

    return ShortAccumWidth - ShortAccumScale - 1;

  }

  /// getAccumScale/IBits - Return the number of fractional/integral bits

  /// in a 'signed _Accum' type.

  unsigned getAccumScale() const { return AccumScale; }

  unsigned getAccumIBits() const { return AccumWidth - AccumScale - 1; }

  /// getLongAccumScale/IBits - Return the number of fractional/integral bits

  /// in a 'signed long _Accum' type.

  unsigned getLongAccumScale() const { return LongAccumScale; }

  unsigned getLongAccumIBits() const {

    return LongAccumWidth - LongAccumScale - 1;

  }

  /// getUnsignedShortAccumScale/IBits - Return the number of

  /// fractional/integral bits in a 'unsigned short _Accum' type.

  unsigned getUnsignedShortAccumScale() const {

    return PaddingOnUnsignedFixedPoint ? ShortAccumScale : ShortAccumScale + 1;

  }

  unsigned getUnsignedShortAccumIBits() const {

    return PaddingOnUnsignedFixedPoint

               ? getShortAccumIBits()

               : ShortAccumWidth - getUnsignedShortAccumScale();

  }

  /// getUnsignedAccumScale/IBits - Return the number of fractional/integral

  /// bits in a 'unsigned _Accum' type.

  unsigned getUnsignedAccumScale() const {

    return PaddingOnUnsignedFixedPoint ? AccumScale : AccumScale + 1;

  }

  unsigned getUnsignedAccumIBits() const {

    return PaddingOnUnsignedFixedPoint ? getAccumIBits()

                                       : AccumWidth - getUnsignedAccumScale();

  }

  /// getUnsignedLongAccumScale/IBits - Return the number of fractional/integral

  /// bits in a 'unsigned long _Accum' type.

  unsigned getUnsignedLongAccumScale() const {

    return PaddingOnUnsignedFixedPoint ? LongAccumScale : LongAccumScale + 1;

  }

  unsigned getUnsignedLongAccumIBits() const {

    return PaddingOnUnsignedFixedPoint

               ? getLongAccumIBits()

               : LongAccumWidth - getUnsignedLongAccumScale();

  }

  /// getShortFractScale - Return the number of fractional bits

  /// in a 'signed short _Fract' type.

  unsigned getShortFractScale() const { return ShortFractWidth - 1; }

  /// getFractScale - Return the number of fractional bits

  /// in a 'signed _Fract' type.

  unsigned getFractScale() const { return FractWidth - 1; }

  /// getLongFractScale - Return the number of fractional bits

  /// in a 'signed long _Fract' type.

  unsigned getLongFractScale() const { return LongFractWidth - 1; }

  /// getUnsignedShortFractScale - Return the number of fractional bits

  /// in a 'unsigned short _Fract' type.

  unsigned getUnsignedShortFractScale() const {

    return PaddingOnUnsignedFixedPoint ? getShortFractScale()

                                       : getShortFractScale() + 1;

  }

  /// getUnsignedFractScale - Return the number of fractional bits

  /// in a 'unsigned _Fract' type.

  unsigned getUnsignedFractScale() const {

    return PaddingOnUnsignedFixedPoint ? getFractScale() : getFractScale() + 1;

  }

  /// getUnsignedLongFractScale - Return the number of fractional bits

  /// in a 'unsigned long _Fract' type.

  unsigned getUnsignedLongFractScale() const {

    return PaddingOnUnsignedFixedPoint ? getLongFractScale()

                                       : getLongFractScale() + 1;

  }

  /// Determine whether the __int128 type is supported on this target.

  virtual bool hasInt128Type() const {

    return (getPointerWidth(LangAS::Default) >= 64) ||

           getTargetOpts().ForceEnableInt128;

  } // FIXME

  /// Determine whether the _BitInt type is supported on this target. This

  /// limitation is put into place for ABI reasons.

  /// FIXME: _BitInt is a required type in C23, so there's not much utility in

  /// asking whether the target supported it or not; I think this should be

  /// removed once backends have been alerted to the type and have had the

  /// chance to do implementation work if needed.

  virtual bool hasBitIntType() const {

    return false;

  }

  // Different targets may support a different maximum width for the _BitInt

  // type, depending on what operations are supported.

  virtual size_t getMaxBitIntWidth() const {

    // Consider -fexperimental-max-bitint-width= first.

    if (MaxBitIntWidth)

      return std::min<size_t>(*MaxBitIntWidth, llvm::IntegerType::MAX_INT_BITS);

    // FIXME: this value should be llvm::IntegerType::MAX_INT_BITS, which is

    // maximum bit width that LLVM claims its IR can support. However, most

    // backends currently have a bug where they only support float to int

    // conversion (and vice versa) on types that are <= 128 bits and crash

    // otherwise. We're setting the max supported value to 128 to be

    // conservative.

    return 128;

  }

  /// Determine whether _Float16 is supported on this target.

  virtual bool hasLegalHalfType() const { return HasLegalHalfType; }

  /// Whether half args and returns are supported.

  virtual bool allowHalfArgsAndReturns() const { return HalfArgsAndReturns; }

  /// Determine whether the __float128 type is supported on this target.

  virtual bool hasFloat128Type() const { return HasFloat128; }

  /// Determine whether the _Float16 type is supported on this target.

  virtual bool hasFloat16Type() const { return HasFloat16; }

  /// Determine whether the _BFloat16 type is supported on this target.

  virtual bool hasBFloat16Type() const { return HasBFloat16; }

  /// Determine whether the __ibm128 type is supported on this target.

  virtual bool hasIbm128Type() const { return HasIbm128; }

  /// Determine whether the long double type is supported on this target.

  virtual bool hasLongDoubleType() const { return HasLongDouble; }

  /// Determine whether return of a floating point value is supported

  /// on this target.

  virtual bool hasFPReturn() const { return HasFPReturn; }

  /// Determine whether constrained floating point is supported on this target.

  virtual bool hasStrictFP() const { return HasStrictFP; }

  /// Return the alignment that is the largest alignment ever used for any

  /// scalar/SIMD data type on the target machine you are compiling for

  /// (including types with an extended alignment requirement).

  unsigned getSuitableAlign() const { return SuitableAlign; }

  /// Return the default alignment for __attribute__((aligned)) on

  /// this target, to be used if no alignment value is specified.

  unsigned getDefaultAlignForAttributeAligned() const {

    return DefaultAlignForAttributeAligned;

  }

  /// getMinGlobalAlign - Return the minimum alignment of a global variable,

  /// unless its alignment is explicitly reduced via attributes.

  virtual unsigned getMinGlobalAlign (uint64_t) const {

    return MinGlobalAlign;

  }

  /// Return the largest alignment for which a suitably-sized allocation with

  /// '::operator new(size_t)' is guaranteed to produce a correctly-aligned

  /// pointer.

  unsigned getNewAlign() const {

    return NewAlign ? NewAlign : std::max(LongDoubleAlign, LongLongAlign);

  }

  /// getWCharWidth/Align - Return the size of 'wchar_t' for this target, in

  /// bits.

  unsigned getWCharWidth() const { return getTypeWidth(WCharType); }

  unsigned getWCharAlign() const { return getTypeAlign(WCharType); }

  /// getChar16Width/Align - Return the size of 'char16_t' for this target, in

  /// bits.

  unsigned getChar16Width() const { return getTypeWidth(Char16Type); }

  unsigned getChar16Align() const { return getTypeAlign(Char16Type); }

  /// getChar32Width/Align - Return the size of 'char32_t' for this target, in

  /// bits.

  unsigned getChar32Width() const { return getTypeWidth(Char32Type); }

  unsigned getChar32Align() const { return getTypeAlign(Char32Type); }

  /// getHalfWidth/Align/Format - Return the size/align/format of 'half'.

  unsigned getHalfWidth() const { return HalfWidth; }

  unsigned getHalfAlign() const { return HalfAlign; }

  const llvm::fltSemantics &getHalfFormat() const { return *HalfFormat; }

  /// getFloatWidth/Align/Format - Return the size/align/format of 'float'.

  unsigned getFloatWidth() const { return FloatWidth; }

  unsigned getFloatAlign() const { return FloatAlign; }

  const llvm::fltSemantics &getFloatFormat() const { return *FloatFormat; }

  /// getBFloat16Width/Align/Format - Return the size/align/format of '__bf16'.

  unsigned getBFloat16Width() const { return BFloat16Width; }

  unsigned getBFloat16Align() const { return BFloat16Align; }

  const llvm::fltSemantics &getBFloat16Format() const { return *BFloat16Format; }

  /// getDoubleWidth/Align/Format - Return the size/align/format of 'double'.

  unsigned getDoubleWidth() const { return DoubleWidth; }

  unsigned getDoubleAlign() const { return DoubleAlign; }

  const llvm::fltSemantics &getDoubleFormat() const { return *DoubleFormat; }

  /// getLongDoubleWidth/Align/Format - Return the size/align/format of 'long

  /// double'.

  unsigned getLongDoubleWidth() const { return LongDoubleWidth; }

  unsigned getLongDoubleAlign() const { return LongDoubleAlign; }

  const llvm::fltSemantics &getLongDoubleFormat() const {

    return *LongDoubleFormat;

  }

  /// getFloat128Width/Align/Format - Return the size/align/format of

  /// '__float128'.

  unsigned getFloat128Width() const { return 128; }

  unsigned getFloat128Align() const { return Float128Align; }

  const llvm::fltSemantics &getFloat128Format() const {

    return *Float128Format;

  }

  /// getIbm128Width/Align/Format - Return the size/align/format of

  /// '__ibm128'.

  unsigned getIbm128Width() const { return 128; }

  unsigned getIbm128Align() const { return Ibm128Align; }

  const llvm::fltSemantics &getIbm128Format() const { return *Ibm128Format; }

  /// Return the mangled code of long double.

  virtual const char *getLongDoubleMangling() const { return "e"; }

  /// Return the mangled code of __float128.

  virtual const char *getFloat128Mangling() const { return "g"; }

  /// Return the mangled code of __ibm128.

  virtual const char *getIbm128Mangling() const {

    llvm_unreachable("ibm128 not implemented on this target");

  }

  /// Return the mangled code of bfloat.

  virtual const char *getBFloat16Mangling() const {

    llvm_unreachable("bfloat not implemented on this target");

  }

  /// Return the value for the C99 FLT_EVAL_METHOD macro.

  virtual LangOptions::FPEvalMethodKind getFPEvalMethod() const {

    return LangOptions::FPEvalMethodKind::FEM_Source;

  }

  virtual bool supportSourceEvalMethod() const { return true; }

  // getLargeArrayMinWidth/Align - Return the minimum array size that is

  // 'large' and its alignment.

  unsigned getLargeArrayMinWidth() const { return LargeArrayMinWidth; }

  unsigned getLargeArrayAlign() const { return LargeArrayAlign; }

  /// Return the maximum width lock-free atomic operation which will

  /// ever be supported for the given target

  unsigned getMaxAtomicPromoteWidth() const { return MaxAtomicPromoteWidth; }

  /// Return the maximum width lock-free atomic operation which can be

  /// inlined given the supported features of the given target.

  unsigned getMaxAtomicInlineWidth() const { return MaxAtomicInlineWidth; }

  /// Set the maximum inline or promote width lock-free atomic operation

  /// for the given target.

  virtual void setMaxAtomicWidth() {}

  /// Returns true if the given target supports lock-free atomic

  /// operations at the specified width and alignment.

  virtual bool hasBuiltinAtomic(uint64_t AtomicSizeInBits,

                                uint64_t AlignmentInBits) const {

    return AtomicSizeInBits <= AlignmentInBits &&

           AtomicSizeInBits <= getMaxAtomicInlineWidth() &&

           (AtomicSizeInBits <= getCharWidth() ||

            llvm::isPowerOf2_64(AtomicSizeInBits / getCharWidth()));

  }

  /// Return the maximum vector alignment supported for the given target.

  unsigned getMaxVectorAlign() const { return MaxVectorAlign; }

  /// Return default simd alignment for the given target. Generally, this

  /// value is type-specific, but this alignment can be used for most of the

  /// types for the given target.

  unsigned getSimdDefaultAlign() const { return SimdDefaultAlign; }

  unsigned getMaxOpenCLWorkGroupSize() const { return MaxOpenCLWorkGroupSize; }

  /// Return the alignment (in bits) of the thrown exception object. This is

  /// only meaningful for targets that allocate C++ exceptions in a system

  /// runtime, such as those using the Itanium C++ ABI.

  virtual unsigned getExnObjectAlignment() const {

    // Itanium says that an _Unwind_Exception has to be "double-word"

    // aligned (and thus the end of it is also so-aligned), meaning 16

    // bytes.  Of course, that was written for the actual Itanium,

    // which is a 64-bit platform.  Classically, the ABI doesn't really

    // specify the alignment on other platforms, but in practice

    // libUnwind declares the struct with __attribute__((aligned)), so

    // we assume that alignment here.  (It's generally 16 bytes, but

    // some targets overwrite it.)

    return getDefaultAlignForAttributeAligned();

  }

  /// Return the size of intmax_t and uintmax_t for this target, in bits.

  unsigned getIntMaxTWidth() const {

    return getTypeWidth(IntMaxType);

  }

  // Return the size of unwind_word for this target.

  virtual unsigned getUnwindWordWidth() const {

    return getPointerWidth(LangAS::Default);

  }

  /// Return the "preferred" register width on this target.

  virtual unsigned getRegisterWidth() const {

    // Currently we assume the register width on the target matches the pointer

    // width, we can introduce a new variable for this if/when some target wants

    // it.

    return PointerWidth;