Types.h

Go to the documentation of this file.

//===- ABI/Types.h ----------------------------------------------*- 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
/// This file defines the type system for the LLVMABI library, which mirrors
/// ABI-relevant aspects of frontend types.
///
//===----------------------------------------------------------------------===//
#ifndef LLVM_ABI_TYPES_H
#define LLVM_ABI_TYPES_H
 
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/Support/Alignment.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/TypeSize.h"
 
namespace llvm {
namespace abi {
 
enum class TypeKind {
  Void,
  Atomic,
  MemberPointer,
  Complex,
  Integer,
  Float,
  Pointer,
  Array,
  Vector,
  Tuple,
  Record,
};
 
/// Represents the ABI-specific view of a type in LLVM.
///
/// This abstracts platform and language-specific ABI details from the
/// frontend, providing a consistent interface for the ABI Library.
class Type {
private:
  TypeSize getTypeStoreSize() const {
    TypeSize StoreSizeInBits = getTypeStoreSizeInBits();
    return {StoreSizeInBits.getKnownMinValue() / 8,
            StoreSizeInBits.isScalable()};
  }
  TypeSize getTypeStoreSizeInBits() const {
    TypeSize BaseSize = getSizeInBits();
    uint64_t AlignedSizeInBits =
        alignToPowerOf2(BaseSize.getKnownMinValue(), 8);
    return {AlignedSizeInBits, BaseSize.isScalable()};
  }
 
protected:
  TypeKind Kind;
  TypeSize SizeInBits;
  Align ABIAlignment;
  Align UnadjustedAlignment;
 
  Type(TypeKind K, TypeSize SizeInBits, Align ABIAlign)
      : Type(K, SizeInBits, ABIAlign, ABIAlign) {}
  Type(TypeKind K, TypeSize SizeInBits, Align ABIAlign, Align UnadjustedAlign)
      : Kind(K), SizeInBits(SizeInBits), ABIAlignment(ABIAlign),
        UnadjustedAlignment(UnadjustedAlign) {}
 
public:
  TypeKind getKind() const { return Kind; }
  TypeSize getSizeInBits() const { return SizeInBits; }
 
  /// Returns the size in bits if it is fixed, otherwise 0.
  uint64_t getFixedSizeInBitsOrZero() const {
    return SizeInBits.isFixed() ? SizeInBits.getFixedValue() : 0;
  }
 
  /// Returns the size in bits that the source language gives this type,
  /// including any padding.
  ///
  /// An integer is rounded up to whole bytes.  A _BitInt or a floating-point
  /// type is rounded up further, to its alignment.  That alignment must be the
  /// one its size is padded to, not one an aligned attribute raised or lowered.
  /// A complex type is twice the ABI size of its element type.  A fixed-length
  /// vector counts an integer element other than a _BitInt at its bit width and
  /// every other element at its own ABI size, so a bool element takes one bit.
  /// The total is rounded up to a power of two of at least 8 bits.  Any other
  /// type returns the size it was created with, and a scalable type returns 0.
  LLVM_ABI uint64_t getABISizeInBits() const;
 
  Align getAlignment() const { return ABIAlignment; }
 
  /// Alignment before record-level adjustments such as aligned attributes.
  /// Equal to getAlignment() unless a distinct unadjusted alignment was
  /// provided when the type was created.
  Align getUnadjustedAlignment() const { return UnadjustedAlignment; }
 
  TypeSize getTypeAllocSize() const {
    return alignTo(getTypeStoreSize(), getAlignment().value());
  }
 
  bool isVoid() const { return Kind == TypeKind::Void; }
  bool isAtomic() const { return Kind == TypeKind::Atomic; }
  bool isInteger() const { return Kind == TypeKind::Integer; }
  bool isFloat() const { return Kind == TypeKind::Float; }
  bool isPointer() const { return Kind == TypeKind::Pointer; }
  bool isArray() const { return Kind == TypeKind::Array; }
  bool isVector() const { return Kind == TypeKind::Vector; }
  bool isTuple() const { return Kind == TypeKind::Tuple; }
  bool isRecord() const { return Kind == TypeKind::Record; }
  bool isMemberPointer() const { return Kind == TypeKind::MemberPointer; }
  bool isComplex() const { return Kind == TypeKind::Complex; }
  bool isZeroSize() const { return getSizeInBits().isZero(); }
 
  LLVM_ABI bool isSVESizelessType() const;
 
  /// True if this type is a record that is empty for ABI purposes.
  LLVM_ABI bool isEmptyRecord() const;
};
 
class VoidType : public Type {
public:
  VoidType() : Type(TypeKind::Void, TypeSize::getFixed(0), Align(1)) {}
 
  static bool classof(const Type *T) { return T->getKind() == TypeKind::Void; }
};
 
class AtomicType : public Type {
public:
  AtomicType(const Type *ValueType, uint64_t SizeInBits, Align Alignment)
      : Type(TypeKind::Atomic, TypeSize::getFixed(SizeInBits), Alignment),
        ValueType(ValueType) {}
 
  const Type *getValueType() const { return ValueType; }
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Atomic;
  }
 
private:
  const Type *ValueType;
};
 
class ComplexType : public Type {
public:
  ComplexType(const Type *ElementType, uint64_t SizeInBits, Align Alignment)
      : Type(TypeKind::Complex, TypeSize::getFixed(SizeInBits), Alignment),
        ElementType(ElementType) {}
 
  const Type *getElementType() const { return ElementType; }
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Complex;
  }
 
private:
  const Type *ElementType;
};
 
class IntegerType : public Type {
private:
  bool IsSigned;
  bool IsBitInt;
 
public:
  IntegerType(uint64_t BitWidth, Align ABIAlign, bool IsSigned,
              bool IsBitInt = false)
      : Type(TypeKind::Integer, TypeSize::getFixed(BitWidth), ABIAlign),
        IsSigned(IsSigned), IsBitInt(IsBitInt) {}
 
  bool isSigned() const { return IsSigned; }
  bool isBitInt() const { return IsBitInt; }
  bool isBool() const {
    return getSizeInBits().getFixedValue() == 1 && !IsBitInt;
  }
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Integer;
  }
};
 
class FloatType : public Type {
private:
  const fltSemantics *Semantics;
 
public:
  FloatType(const fltSemantics &FloatSemantics, Align ABIAlign)
      : Type(TypeKind::Float,
             TypeSize::getFixed(APFloat::getSizeInBits(FloatSemantics)),
             ABIAlign),
        Semantics(&FloatSemantics) {}
 
  const fltSemantics *getSemantics() const { return Semantics; }
  static bool classof(const Type *T) { return T->getKind() == TypeKind::Float; }
};
 
class PointerLikeType : public Type {
protected:
  unsigned AddrSpace;
  PointerLikeType(TypeKind K, TypeSize SizeInBits, Align ABIAlign, unsigned AS)
      : Type(K, SizeInBits, ABIAlign), AddrSpace(AS) {}
 
public:
  unsigned getAddrSpace() const { return AddrSpace; }
  bool isMemberPointer() const { return getKind() == TypeKind::MemberPointer; }
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Pointer ||
           T->getKind() == TypeKind::MemberPointer;
  }
};
 
class PointerType : public PointerLikeType {
public:
  PointerType(uint64_t Size, Align ABIAlign, unsigned AddressSpace = 0)
      : PointerLikeType(TypeKind::Pointer, TypeSize::getFixed(Size), ABIAlign,
                        AddressSpace) {}
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Pointer;
  }
};
 
class MemberPointerType : public PointerLikeType {
private:
  bool IsFunctionPointer;
 
public:
  MemberPointerType(bool IsFunctionPointer, uint64_t SizeInBits, Align ABIAlign,
                    unsigned AddressSpace = 0)
      : PointerLikeType(TypeKind::MemberPointer, TypeSize::getFixed(SizeInBits),
                        ABIAlign, AddressSpace),
        IsFunctionPointer(IsFunctionPointer) {}
  bool isFunctionPointer() const { return IsFunctionPointer; }
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::MemberPointer;
  }
};
 
class ArrayType : public Type {
private:
  const Type *ElementType;
  uint64_t NumElements;
  bool IsMatrix;
 
public:
  ArrayType(const Type *ElementType, uint64_t NumElements, uint64_t SizeInBits,
            bool IsMatrixType = false)
      : Type(TypeKind::Array, TypeSize::getFixed(SizeInBits),
             ElementType->getAlignment()),
        ElementType(ElementType), NumElements(NumElements),
        IsMatrix(IsMatrixType) {}
 
  const Type *getElementType() const { return ElementType; }
  uint64_t getNumElements() const { return NumElements; }
  bool isMatrixType() const { return IsMatrix; }
 
  static bool classof(const Type *T) { return T->getKind() == TypeKind::Array; }
};
 
/// Distinguishes the vector flavors that ABIs have to treat differently.
/// Scalability is not part of the kind. It is tracked by the vector's
/// ElementCount, because some flavors have both a scalable and a
/// fixed-length spelling.
enum class VectorKind {
  /// A plain vector, such as a Neon vector or a GCC vector_size vector.
  Generic,
 
  /// An AArch64 SVE data vector, such as svint32_t. Data vectors are
  /// passed in Z registers. Tuples of these vectors use TupleType.
  SVEData,
 
  /// An AArch64 SVE predicate vector, such as svbool_t. These are passed
  /// in P registers. Sizeless predicates have one-bit elements; the
  /// fixed-length arm_sve_vector_bits form keeps unsigned char (i8)
  /// elements, matching the Clang AST. Both use this kind. Tuples of
  /// these vectors use TupleType.
  SVEPredicate,
 
  /// The AArch64 __SVCount_t type. It is opaque rather than a real vector,
  /// but it occupies a predicate register, so it is given the same shape as
  /// svbool_t.
  SVECount,
};
 
class VectorType : public Type {
private:
  const Type *ElementType;
  ElementCount NumElements;
  VectorKind VecKind;
 
  static TypeSize computeSizeInBits(const Type *ElementType,
                                    ElementCount NumElements) {
    return TypeSize(ElementType->getSizeInBits().getFixedValue() *
                        NumElements.getKnownMinValue(),
                    NumElements.isScalable());
  }
 
public:
  VectorType(const Type *ElementType, ElementCount NumElements, Align ABIAlign,
             VectorKind VecKind = VectorKind::Generic)
      : Type(TypeKind::Vector, computeSizeInBits(ElementType, NumElements),
             ABIAlign),
        ElementType(ElementType), NumElements(NumElements), VecKind(VecKind) {}
 
  const Type *getElementType() const { return ElementType; }
  ElementCount getNumElements() const { return NumElements; }
 
  VectorKind getVectorKind() const { return VecKind; }
 
  bool isScalable() const { return NumElements.isScalable(); }
  bool isFixedLength() const { return !NumElements.isScalable(); }
 
  bool isSVEData() const { return VecKind == VectorKind::SVEData; }
  bool isSVEPredicate() const { return VecKind == VectorKind::SVEPredicate; }
  bool isSVECount() const { return VecKind == VectorKind::SVECount; }
 
  bool isFixedLengthSVEData() const { return isFixedLength() && isSVEData(); }
  bool isFixedLengthSVEPredicate() const {
    return isFixedLength() && isSVEPredicate();
  }
 
  /// Returns true for any of the AArch64 SVE flavors.
  bool isSVEType() const { return VecKind != VectorKind::Generic; }
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Vector;
  }
};
 
/// A homogeneous tuple of 2, 3, or 4 identical vectors, such as the
/// AArch64 SVE types svint32x3_t and svboolx2_t.
///
/// The contained vector describes one register-shaped member. Size and
/// alignment of the tuple cover the whole group: size is NumVectors times
/// the vector size, and alignment matches the contained vector.
class TupleType : public Type {
private:
  const VectorType *Vec;
  unsigned NumVectors;
 
public:
  TupleType(const VectorType *Vec, unsigned NumVectors)
      : Type(TypeKind::Tuple, (Vec->getSizeInBits() * NumVectors),
             Vec->getAlignment()),
        Vec(Vec), NumVectors(NumVectors) {}
 
  const VectorType *getVectorType() const { return Vec; }
  unsigned getNumVectors() const { return NumVectors; }
 
  static bool classof(const Type *T) { return T->getKind() == TypeKind::Tuple; }
};
 
struct FieldInfo {
  const Type *FieldType;
  uint64_t OffsetInBits;
  uint64_t BitFieldWidth;
  bool IsBitField;
  bool IsUnnamedBitfield;
  bool HasNoUniqueAddress;
 
  FieldInfo(const Type *FieldType, uint64_t OffsetInBits = 0,
            bool IsBitField = false, uint64_t BitFieldWidth = 0,
            bool IsUnnamedBitField = false, bool HasNoUniqueAddress = false)
      : FieldType(FieldType), OffsetInBits(OffsetInBits),
        BitFieldWidth(BitFieldWidth), IsBitField(IsBitField),
        IsUnnamedBitfield(IsUnnamedBitField),
        HasNoUniqueAddress(HasNoUniqueAddress) {}
 
  LLVM_ABI bool isEmpty() const;
};
 
enum class StructPacking { Default, Packed, ExplicitPacking };
 
enum RecordFlags : unsigned {
  None = 0,
  CanPassInRegisters = 1 << 0,
  IsUnion = 1 << 1,
  IsTransparent = 1 << 2,
  IsCXXRecord = 1 << 3,
  IsPolymorphic = 1 << 4,
  HasFlexibleArrayMember = 1 << 5,
  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ HasFlexibleArrayMember),
};
 
class RecordType : public Type {
private:
  ArrayRef<FieldInfo> Fields;
  ArrayRef<FieldInfo> BaseClasses;
  ArrayRef<FieldInfo> VirtualBaseClasses;
  StructPacking Packing;
  RecordFlags Flags;
 
public:
  RecordType(ArrayRef<FieldInfo> StructFields, ArrayRef<FieldInfo> Bases,
             ArrayRef<FieldInfo> VBases, TypeSize Size, Align ABIAlign,
             Align UnadjustedAlign, StructPacking Pack = StructPacking::Default,
             RecordFlags RecFlags = RecordFlags::None)
      : Type(TypeKind::Record, Size, ABIAlign, UnadjustedAlign),
        Fields(StructFields), BaseClasses(Bases), VirtualBaseClasses(VBases),
        Packing(Pack), Flags(RecFlags) {}
  uint32_t getNumFields() const { return Fields.size(); }
  StructPacking getPacking() const { return Packing; }
 
  bool isUnion() const {
    return static_cast<unsigned>(Flags & RecordFlags::IsUnion) != 0;
  }
  bool isCXXRecord() const {
    return static_cast<unsigned>(Flags & RecordFlags::IsCXXRecord) != 0;
  }
  bool isPolymorphic() const {
    return static_cast<unsigned>(Flags & RecordFlags::IsPolymorphic) != 0;
  }
  bool canPassInRegisters() const {
    return static_cast<unsigned>(Flags & RecordFlags::CanPassInRegisters) != 0;
  }
  bool hasFlexibleArrayMember() const {
    return static_cast<unsigned>(Flags & RecordFlags::HasFlexibleArrayMember) !=
           0;
  }
  uint32_t getNumBaseClasses() const { return BaseClasses.size(); }
  uint32_t getNumVirtualBaseClasses() const {
    return VirtualBaseClasses.size();
  }
  bool isTransparentUnion() const {
    return static_cast<unsigned>(Flags & RecordFlags::IsTransparent) != 0;
  }
  ArrayRef<FieldInfo> getFields() const { return Fields; }
  ArrayRef<FieldInfo> getBaseClasses() const { return BaseClasses; }
  ArrayRef<FieldInfo> getVirtualBaseClasses() const {
    return VirtualBaseClasses;
  }
 
  LLVM_ABI bool isEmpty() const;
 
  /// Returns the field, base, or virtual base whose extent contains
  /// \p OffsetInBits, or nullptr if no such element exists. Empty bases and
  /// unnamed bitfields are skipped.
  LLVM_ABI const FieldInfo *
  getElementContainingOffset(unsigned OffsetInBits) const;
 
  static bool classof(const Type *T) {
    return T->getKind() == TypeKind::Record;
  }
};
 
/// TypeBuilder manages the lifecycle of ABI types using bump pointer
/// allocation. Types created by a TypeBuilder are valid for the lifetime of the
/// allocator.
///
/// Example usage:
/// \code
///   BumpPtrAllocator Alloc;
///   TypeBuilder Builder(Alloc);
///   const auto *IntTy = Builder.getIntegerType(32, Align(4), true);
/// \endcode
class TypeBuilder {
private:
  BumpPtrAllocator &Allocator;
 
public:
  explicit TypeBuilder(BumpPtrAllocator &Alloc) : Allocator(Alloc) {}
 
  const VoidType *getVoidType() {
    return new (Allocator.Allocate<VoidType>()) VoidType();
  }
 
  const AtomicType *getAtomicType(const Type *ValueType, uint64_t SizeInBits,
                                  Align Align) {
    return new (Allocator.Allocate<AtomicType>())
        AtomicType(ValueType, SizeInBits, Align);
  }
 
  const IntegerType *getIntegerType(uint64_t BitWidth, Align Align, bool Signed,
                                    bool IsBitInt = false) {
    return new (Allocator.Allocate<IntegerType>())
        IntegerType(BitWidth, Align, Signed, IsBitInt);
  }
 
  const FloatType *getFloatType(const fltSemantics &Semantics, Align Align) {
    return new (Allocator.Allocate<FloatType>()) FloatType(Semantics, Align);
  }
 
  const PointerType *getPointerType(uint64_t Size, Align Align,
                                    unsigned Addrspace = 0) {
    return new (Allocator.Allocate<PointerType>())
        PointerType(Size, Align, Addrspace);
  }
 
  const ArrayType *getArrayType(const Type *ElementType, uint64_t NumElements,
                                uint64_t SizeInBits,
                                bool IsMatrixType = false) {
    return new (Allocator.Allocate<ArrayType>())
        ArrayType(ElementType, NumElements, SizeInBits, IsMatrixType);
  }
 
  const VectorType *getVectorType(const Type *ElementType,
                                  ElementCount NumElements, Align Align,
                                  VectorKind VecKind = VectorKind::Generic) {
    return new (Allocator.Allocate<VectorType>())
        VectorType(ElementType, NumElements, Align, VecKind);
  }
 
  /// Creates a homogeneous tuple of \p NumVectors copies of \p Vec.
  /// \p NumVectors must be 2, 3, or 4.
  const TupleType *getTupleType(const VectorType *Vec, unsigned NumVectors) {
    assert(NumVectors >= 2 && NumVectors <= 4 &&
           "tuple types hold 2, 3, or 4 vectors");
    return new (Allocator.Allocate<TupleType>()) TupleType(Vec, NumVectors);
  }
 
  /// Creates a scalable predicate or count vector.
  /// Note: The AArch64 __SVCount_t type is opaque, so it is modeled with the
  /// shape of svbool_t: a scalable vector of 16 one-bit elements.
  const VectorType *getScalablePredicateOrCountVectorType(Align ABIAlign,
                                                          VectorKind Kind) {
    assert((Kind == VectorKind::SVEPredicate || Kind == VectorKind::SVECount) &&
           "expected predicate or count vector kind");
    const Type *PredicateBit =
        getIntegerType(1, Align(1), /*Signed=*/false, /*IsBitInt=*/false);
    return getVectorType(PredicateBit, ElementCount::getScalable(16), ABIAlign,
                         Kind);
  }
 
  const RecordType *getRecordType(ArrayRef<FieldInfo> Fields, TypeSize Size,
                                  Align ABIAlign, Align UnadjustedAlign,
                                  StructPacking Pack = StructPacking::Default,
                                  ArrayRef<FieldInfo> BaseClasses = {},
                                  ArrayRef<FieldInfo> VirtualBaseClasses = {},
                                  RecordFlags RecFlags = RecordFlags::None) {
    FieldInfo *FieldArray = Allocator.Allocate<FieldInfo>(Fields.size());
    std::copy(Fields.begin(), Fields.end(), FieldArray);
 
    FieldInfo *BaseArray = nullptr;
    if (!BaseClasses.empty()) {
      BaseArray = Allocator.Allocate<FieldInfo>(BaseClasses.size());
      std::copy(BaseClasses.begin(), BaseClasses.end(), BaseArray);
    }
 
    FieldInfo *VBaseArray = nullptr;
    if (!VirtualBaseClasses.empty()) {
      VBaseArray = Allocator.Allocate<FieldInfo>(VirtualBaseClasses.size());
      std::copy(VirtualBaseClasses.begin(), VirtualBaseClasses.end(),
                VBaseArray);
    }
 
    ArrayRef<FieldInfo> FieldsRef(FieldArray, Fields.size());
    ArrayRef<FieldInfo> BasesRef(BaseArray, BaseClasses.size());
    ArrayRef<FieldInfo> VBasesRef(VBaseArray, VirtualBaseClasses.size());
 
    return new (Allocator.Allocate<RecordType>())
        RecordType(FieldsRef, BasesRef, VBasesRef, Size, ABIAlign,
                   UnadjustedAlign, Pack, RecFlags);
  }
 
  const RecordType *getUnionType(ArrayRef<FieldInfo> Fields, TypeSize Size,
                                 Align ABIAlign, Align UnadjustedAlign,
                                 StructPacking Pack = StructPacking::Default,
                                 RecordFlags RecFlags = RecordFlags::None) {
    FieldInfo *FieldArray = Allocator.Allocate<FieldInfo>(Fields.size());
 
    for (size_t I = 0, E = Fields.size(); I != E; ++I) {
      FieldInfo Field = Fields[I];
      Field.OffsetInBits = 0;
      new (&FieldArray[I]) FieldInfo(Field);
    }
 
    ArrayRef<FieldInfo> FieldsRef(FieldArray, Fields.size());
 
    return new (Allocator.Allocate<RecordType>()) RecordType(
        FieldsRef, ArrayRef<FieldInfo>(), ArrayRef<FieldInfo>(), Size, ABIAlign,
        UnadjustedAlign, Pack, RecFlags | RecordFlags::IsUnion);
  }
 
  const ComplexType *getComplexType(const Type *ElementType, Align Align) {
    // Complex types have two elements (real and imaginary parts)
    uint64_t ElementSizeInBits = ElementType->getSizeInBits().getFixedValue();
    uint64_t ComplexSizeInBits = ElementSizeInBits * 2;
 
    return new (Allocator.Allocate<ComplexType>())
        ComplexType(ElementType, ComplexSizeInBits, Align);
  }
 
  const MemberPointerType *getMemberPointerType(bool IsFunctionPointer,
                                                uint64_t SizeInBits,
                                                Align Align) {
    return new (Allocator.Allocate<MemberPointerType>())
        MemberPointerType(IsFunctionPointer, SizeInBits, Align);
  }
};
 
} // namespace abi
} // namespace llvm
 
#endif