BuiltinTypes.cpp | Explore in Territory

//===- BuiltinTypes.cpp - C Interface to MLIR Builtin Types ---------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "mlir-c/BuiltinTypes.h"
#include "mlir-c/AffineMap.h"
#include "mlir-c/IR.h"
#include "mlir-c/Support.h"
#include "mlir/CAPI/AffineMap.h"
#include "mlir/CAPI/IR.h"
#include "mlir/CAPI/Support.h"
#include "mlir/IR/AffineMap.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Types.h"

#include <algorithm>

usingnamespacemlir;

//===----------------------------------------------------------------------===//
// Integer types.
//===----------------------------------------------------------------------===//

MlirTypeID mlirIntegerTypeGetTypeID() { … }

bool mlirTypeIsAInteger(MlirType type) { … }

MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) { … }

MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) { … }

MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) { … }

unsigned mlirIntegerTypeGetWidth(MlirType type) { … }

bool mlirIntegerTypeIsSignless(MlirType type) { … }

bool mlirIntegerTypeIsSigned(MlirType type) { … }

bool mlirIntegerTypeIsUnsigned(MlirType type) { … }

//===----------------------------------------------------------------------===//
// Index type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirIndexTypeGetTypeID() { … }

bool mlirTypeIsAIndex(MlirType type) { … }

MlirType mlirIndexTypeGet(MlirContext ctx) { … }

//===----------------------------------------------------------------------===//
// Floating-point types.
//===----------------------------------------------------------------------===//

bool mlirTypeIsAFloat(MlirType type) { … }

unsigned mlirFloatTypeGetWidth(MlirType type) { … }

MlirTypeID mlirFloat8E5M2TypeGetTypeID() { … }

bool mlirTypeIsAFloat8E5M2(MlirType type) { … }

MlirType mlirFloat8E5M2TypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat8E4M3TypeGetTypeID() { … }

bool mlirTypeIsAFloat8E4M3(MlirType type) { … }

MlirType mlirFloat8E4M3TypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat8E4M3FNTypeGetTypeID() { … }

bool mlirTypeIsAFloat8E4M3FN(MlirType type) { … }

MlirType mlirFloat8E4M3FNTypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat8E5M2FNUZTypeGetTypeID() { … }

bool mlirTypeIsAFloat8E5M2FNUZ(MlirType type) { … }

MlirType mlirFloat8E5M2FNUZTypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat8E4M3FNUZTypeGetTypeID() { … }

bool mlirTypeIsAFloat8E4M3FNUZ(MlirType type) { … }

MlirType mlirFloat8E4M3FNUZTypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat8E4M3B11FNUZTypeGetTypeID() { … }

bool mlirTypeIsAFloat8E4M3B11FNUZ(MlirType type) { … }

MlirType mlirFloat8E4M3B11FNUZTypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat8E3M4TypeGetTypeID() { … }

bool mlirTypeIsAFloat8E3M4(MlirType type) { … }

MlirType mlirFloat8E3M4TypeGet(MlirContext ctx) { … }

MlirTypeID mlirBFloat16TypeGetTypeID() { … }

bool mlirTypeIsABF16(MlirType type) { … }

MlirType mlirBF16TypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat16TypeGetTypeID() { … }

bool mlirTypeIsAF16(MlirType type) { … }

MlirType mlirF16TypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloatTF32TypeGetTypeID() { … }

bool mlirTypeIsATF32(MlirType type) { … }

MlirType mlirTF32TypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat32TypeGetTypeID() { … }

bool mlirTypeIsAF32(MlirType type) { … }

MlirType mlirF32TypeGet(MlirContext ctx) { … }

MlirTypeID mlirFloat64TypeGetTypeID() { … }

bool mlirTypeIsAF64(MlirType type) { … }

MlirType mlirF64TypeGet(MlirContext ctx) { … }

//===----------------------------------------------------------------------===//
// None type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirNoneTypeGetTypeID() { … }

bool mlirTypeIsANone(MlirType type) { … }

MlirType mlirNoneTypeGet(MlirContext ctx) { … }

//===----------------------------------------------------------------------===//
// Complex type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirComplexTypeGetTypeID() { … }

bool mlirTypeIsAComplex(MlirType type) { … }

MlirType mlirComplexTypeGet(MlirType elementType) { … }

MlirType mlirComplexTypeGetElementType(MlirType type) { … }

//===----------------------------------------------------------------------===//
// Shaped type.
//===----------------------------------------------------------------------===//

bool mlirTypeIsAShaped(MlirType type) { … }

MlirType mlirShapedTypeGetElementType(MlirType type) { … }

bool mlirShapedTypeHasRank(MlirType type) { … }

int64_t mlirShapedTypeGetRank(MlirType type) { … }

bool mlirShapedTypeHasStaticShape(MlirType type) { … }

bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) { … }

int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim) { … }

int64_t mlirShapedTypeGetDynamicSize() { … }

bool mlirShapedTypeIsDynamicSize(int64_t size) { … }

bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) { … }

int64_t mlirShapedTypeGetDynamicStrideOrOffset() { … }

//===----------------------------------------------------------------------===//
// Vector type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirVectorTypeGetTypeID() { … }

bool mlirTypeIsAVector(MlirType type) { … }

MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
                           MlirType elementType) { … }

MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank,
                                  const int64_t *shape, MlirType elementType) { … }

MlirType mlirVectorTypeGetScalable(intptr_t rank, const int64_t *shape,
                                   const bool *scalable, MlirType elementType) { … }

MlirType mlirVectorTypeGetScalableChecked(MlirLocation loc, intptr_t rank,
                                          const int64_t *shape,
                                          const bool *scalable,
                                          MlirType elementType) { … }

bool mlirVectorTypeIsScalable(MlirType type) { … }

bool mlirVectorTypeIsDimScalable(MlirType type, intptr_t dim) { … }

//===----------------------------------------------------------------------===//
// Ranked / Unranked tensor type.
//===----------------------------------------------------------------------===//

bool mlirTypeIsATensor(MlirType type) { … }

MlirTypeID mlirRankedTensorTypeGetTypeID() { … }

bool mlirTypeIsARankedTensor(MlirType type) { … }

MlirTypeID mlirUnrankedTensorTypeGetTypeID() { … }

bool mlirTypeIsAUnrankedTensor(MlirType type) { … }

MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
                                 MlirType elementType, MlirAttribute encoding) { … }

MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
                                        const int64_t *shape,
                                        MlirType elementType,
                                        MlirAttribute encoding) { … }

MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type) { … }

MlirType mlirUnrankedTensorTypeGet(MlirType elementType) { … }

MlirType mlirUnrankedTensorTypeGetChecked(MlirLocation loc,
                                          MlirType elementType) { … }

MlirType mlirUnrankedTensorTypeGetElementType(MlirType type) { … }

//===----------------------------------------------------------------------===//
// Ranked / Unranked MemRef type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirMemRefTypeGetTypeID() { … }

bool mlirTypeIsAMemRef(MlirType type) { … }

MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
                           const int64_t *shape, MlirAttribute layout,
                           MlirAttribute memorySpace) { … }

MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType,
                                  intptr_t rank, const int64_t *shape,
                                  MlirAttribute layout,
                                  MlirAttribute memorySpace) { … }

MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
                                     const int64_t *shape,
                                     MlirAttribute memorySpace) { … }

MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc,
                                            MlirType elementType, intptr_t rank,
                                            const int64_t *shape,
                                            MlirAttribute memorySpace) { … }

MlirAttribute mlirMemRefTypeGetLayout(MlirType type) { … }

MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type) { … }

MlirAttribute mlirMemRefTypeGetMemorySpace(MlirType type) { … }

MlirLogicalResult mlirMemRefTypeGetStridesAndOffset(MlirType type,
                                                    int64_t *strides,
                                                    int64_t *offset) { … }

MlirTypeID mlirUnrankedMemRefTypeGetTypeID() { … }

bool mlirTypeIsAUnrankedMemRef(MlirType type) { … }

MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
                                   MlirAttribute memorySpace) { … }

MlirType mlirUnrankedMemRefTypeGetChecked(MlirLocation loc,
                                          MlirType elementType,
                                          MlirAttribute memorySpace) { … }

MlirAttribute mlirUnrankedMemrefGetMemorySpace(MlirType type) { … }

//===----------------------------------------------------------------------===//
// Tuple type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirTupleTypeGetTypeID() { … }

bool mlirTypeIsATuple(MlirType type) { … }

MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                          MlirType const *elements) { … }

intptr_t mlirTupleTypeGetNumTypes(MlirType type) { … }

MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) { … }

//===----------------------------------------------------------------------===//
// Function type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirFunctionTypeGetTypeID() { … }

bool mlirTypeIsAFunction(MlirType type) { … }

MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                             MlirType const *inputs, intptr_t numResults,
                             MlirType const *results) { … }

intptr_t mlirFunctionTypeGetNumInputs(MlirType type) { … }

intptr_t mlirFunctionTypeGetNumResults(MlirType type) { … }

MlirType mlirFunctionTypeGetInput(MlirType type, intptr_t pos) { … }

MlirType mlirFunctionTypeGetResult(MlirType type, intptr_t pos) { … }

//===----------------------------------------------------------------------===//
// Opaque type.
//===----------------------------------------------------------------------===//

MlirTypeID mlirOpaqueTypeGetTypeID() { … }

bool mlirTypeIsAOpaque(MlirType type) { … }

MlirType mlirOpaqueTypeGet(MlirContext ctx, MlirStringRef dialectNamespace,
                           MlirStringRef typeData) { … }

MlirStringRef mlirOpaqueTypeGetDialectNamespace(MlirType type) { … }

MlirStringRef mlirOpaqueTypeGetData(MlirType type) { … }
llvm/mlir/lib/CAPI/IR/BuiltinTypes.cpp
