llvm/mlir/lib/CAPI/IR/AffineMap.cpp

//===- AffineMap.cpp - C API for MLIR Affine Maps -------------------------===//
//
// 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/AffineMap.h"
#include "mlir-c/IR.h"
#include "mlir/CAPI/AffineExpr.h"
#include "mlir/CAPI/AffineMap.h"
#include "mlir/CAPI/IR.h"
#include "mlir/CAPI/Utils.h"
#include "mlir/IR/AffineMap.h"

// TODO: expose the C API related to `AffineExpr` and mutable affine map.

usingnamespacemlir;

MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap) { … }

bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2) { … }

void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
                        void *userData) { … }

void mlirAffineMapDump(MlirAffineMap affineMap) { … }

MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx) { … }

MlirAffineMap mlirAffineMapZeroResultGet(MlirContext ctx, intptr_t dimCount,
                                         intptr_t symbolCount) { … }

MlirAffineMap mlirAffineMapGet(MlirContext ctx, intptr_t dimCount,
                               intptr_t symbolCount, intptr_t nAffineExprs,
                               MlirAffineExpr *affineExprs) { … }

MlirAffineMap mlirAffineMapConstantGet(MlirContext ctx, int64_t val) { … }

MlirAffineMap mlirAffineMapMultiDimIdentityGet(MlirContext ctx,
                                               intptr_t numDims) { … }

MlirAffineMap mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims,
                                            intptr_t results) { … }

MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size,
                                          unsigned *permutation) { … }

bool mlirAffineMapIsIdentity(MlirAffineMap affineMap) { … }

bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) { … }

bool mlirAffineMapIsEmpty(MlirAffineMap affineMap) { … }

bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap) { … }

int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap) { … }

intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap) { … }

intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap) { … }

intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap) { … }

MlirAffineExpr mlirAffineMapGetResult(MlirAffineMap affineMap, intptr_t pos) { … }

intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap) { … }

bool mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap) { … }

bool mlirAffineMapIsPermutation(MlirAffineMap affineMap) { … }

MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                     intptr_t *resultPos) { … }

MlirAffineMap mlirAffineMapGetMajorSubMap(MlirAffineMap affineMap,
                                          intptr_t numResults) { … }

MlirAffineMap mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap,
                                          intptr_t numResults) { … }

MlirAffineMap mlirAffineMapReplace(MlirAffineMap affineMap,
                                   MlirAffineExpr expression,
                                   MlirAffineExpr replacement,
                                   intptr_t numResultDims,
                                   intptr_t numResultSyms) { … }

void mlirAffineMapCompressUnusedSymbols(
    MlirAffineMap *affineMaps, intptr_t size, void *result,
    void (*populateResult)(void *res, intptr_t idx, MlirAffineMap m)) { … }