================ @@ -0,0 +1,543 @@ +//===- 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 Types and related helper methods concerned to the +/// LLVMABI library which mirrors ABI related type information from +/// the LLVM frontend. +/// +//===----------------------------------------------------------------------===// +#ifndef LLVM_ABI_TYPES_H +#define LLVM_ABI_TYPES_H + +#include "llvm/ADT/APFloat.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/Support/Alignment.h" +#include "llvm/Support/Allocator.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/TypeSize.h" +#include <algorithm> +#include <cstdint> + +namespace llvm { +namespace abi { + +enum class TypeKind { + Void, + MemberPointer, + Complex, + Integer, + Float, + Pointer, + Array, + Vector, + Struct, +}; + +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; + + Type(TypeKind K, TypeSize Size, Align Align) + : Kind(K), SizeInBits(Size), ABIAlignment(Align) {} + +public: + TypeKind getKind() const { return Kind; } + TypeSize getSizeInBits() const { return SizeInBits; } + Align getAlignment() const { return ABIAlignment; } + + TypeSize getTypeAllocSize() const { + return alignTo(getTypeStoreSize(), getAlignment().value()); + } + + bool isVoid() const { return Kind == TypeKind::Void; } + 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 isStruct() const { return Kind == TypeKind::Struct; } + bool isMemberPointer() const { return Kind == TypeKind::MemberPointer; } + bool isComplex() const { return Kind == TypeKind::Complex; } +}; + +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 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 IsBoolean; + bool IsBitInt; + bool IsPromotable; + +public: + IntegerType(uint64_t BitWidth, Align Align, bool Signed, bool IsBool = false, + bool BitInt = false, bool IsPromotableInt = false) + : Type(TypeKind::Integer, TypeSize::getFixed(BitWidth), Align), + IsSigned(Signed), IsBoolean(IsBool), IsBitInt(BitInt), + IsPromotable(IsPromotableInt) {} + + bool isSigned() const { return IsSigned; } + bool isBool() const { return IsBoolean; } + bool isBitInt() const { return IsBitInt; } + bool isPromotableIntegerType() const { return IsPromotable; } + + 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 Align) + : Type(TypeKind::Float, + TypeSize::getFixed(APFloat::getSizeInBits(FloatSemantics)), Align), + 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 Size, Align Align, unsigned AS = 0) + : Type(K, Size, Align), AddrSpace(AS) {} + +public: + virtual ~PointerLikeType() = default; + 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 Align, unsigned AddressSpace = 0) + : PointerLikeType(TypeKind::Pointer, TypeSize::getFixed(Size), Align, + 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 Alignment, unsigned AddressSpace = 0) + : PointerLikeType(TypeKind::MemberPointer, TypeSize::getFixed(SizeInBits), + Alignment, 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 *ElemType, uint64_t NumElems, bool IsMatrixType = false) + : Type(TypeKind::Array, ElemType->getSizeInBits() * NumElems, ---------------- nikic wrote:
Is this the correct size if the elements are not byte-sized? E.g. an array of `_BitInt(5)` with 5 elements probably has total size `5*8` rather than `5*5`, as the elements aren't tightly packed like in a vector. Might make sense to pass down the size explicitly? https://github.com/llvm/llvm-project/pull/140112 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
