llvm-project/mlir/include/mlir-c/AffineExpr.h

//===-- mlir-c/AffineExpr.h - C API for MLIR Affine Expressions ---*- 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
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_C_AFFINEEXPR_H
#define MLIR_C_AFFINEEXPR_H

#include "mlir-c/AffineMap.h"
#include "mlir-c/IR.h"

#ifdef __cplusplus
extern "C" {
#endif

//===----------------------------------------------------------------------===//
/** Opaque type declarations.
 *
 * Types are exposed to C bindings as structs containing opaque pointers. They
 * are not supposed to be inspected from C. This allows the underlying
 * representation to change without affecting the API users. The use of structs
 * instead of typedefs enables some type safety as structs are not implicitly
 * convertible to each other.
 *
 * Instances of these types may or may not own the underlying object. The
 * ownership semantics is defined by how an instance of the type was obtained.
 */
//===----------------------------------------------------------------------===//

#define DEFINE_C_API_STRUCT(name, storage)                                     \
  struct name {                                                                \
    storage *ptr;                                                              \
  };                                                                           \
  typedef struct name name

DEFINE_C_API_STRUCT(MlirAffineExpr, const void);

#undef DEFINE_C_API_STRUCT

/// Gets the context that owns the affine expression.
MlirContext mlirAffineExprGetContext(MlirAffineExpr affineExpr);

/** Prints an affine expression by sending chunks of the string representation
 * and forwarding `userData to `callback`. Note that the callback may be called
 * several times with consecutive chunks of the string. */
void mlirAffineExprPrint(MlirAffineExpr affineExpr, MlirStringCallback callback,
                         void *userData);

/// Prints the affine expression to the standard error stream.
void mlirAffineExprDump(MlirAffineExpr affineExpr);

/** Checks whether the given affine expression is made out of only symbols and
 * constants. */
int mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr);

/** Checks whether the given affine expression is a pure affine expression, i.e.
 * mul, floordiv, ceildic, and mod is only allowed w.r.t constants. */
int mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);

/** Returns the greatest known integral divisor of this affine expression. The
 * result is always positive. */
int64_t mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr);

/// Checks whether the given affine expression is a multiple of 'factor'.
int mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor);

/** Checks whether the given affine expression involves AffineDimExpr
 * 'position'. */
int mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr, intptr_t position);

//===----------------------------------------------------------------------===//
// Affine Dimension Expression.
//===----------------------------------------------------------------------===//

/// Creates an affine dimension expression with 'position' in the context.
MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position);

/// Returns the position of the given affine dimension expression.
intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr);

//===----------------------------------------------------------------------===//
// Affine Symbol Expression.
//===----------------------------------------------------------------------===//

/// Creates an affine symbol expression with 'position' in the context.
MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position);

/// Returns the position of the given affine symbol expression.
intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr);

//===----------------------------------------------------------------------===//
// Affine Constant Expression.
//===----------------------------------------------------------------------===//

/// Creates an affine constant expression with 'constant' in the context.
MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant);

/// Returns the value of the given affine constant expression.
int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr);

//===----------------------------------------------------------------------===//
// Affine Add Expression.
//===----------------------------------------------------------------------===//

/// Checks whether the given affine expression is an add expression.
int mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);

/// Creates an affine add expression with 'lhs' and 'rhs'.
MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);

//===----------------------------------------------------------------------===//
// Affine Mul Expression.
//===----------------------------------------------------------------------===//

/// Checks whether the given affine expression is an mul expression.
int mlirAffineExprIsAMul(MlirAffineExpr affineExpr);

/// Creates an affine mul expression with 'lhs' and 'rhs'.
MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);

//===----------------------------------------------------------------------===//
// Affine Mod Expression.
//===----------------------------------------------------------------------===//

/// Checks whether the given affine expression is an mod expression.
int mlirAffineExprIsAMod(MlirAffineExpr affineExpr);

/// Creates an affine mod expression with 'lhs' and 'rhs'.
MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);

//===----------------------------------------------------------------------===//
// Affine FloorDiv Expression.
//===----------------------------------------------------------------------===//

/// Checks whether the given affine expression is an floordiv expression.
int mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);

/// Creates an affine floordiv expression with 'lhs' and 'rhs'.
MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                         MlirAffineExpr rhs);

//===----------------------------------------------------------------------===//
// Affine CeilDiv Expression.
//===----------------------------------------------------------------------===//

/// Checks whether the given affine expression is an ceildiv expression.
int mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);

/// Creates an affine ceildiv expression with 'lhs' and 'rhs'.
MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs);

//===----------------------------------------------------------------------===//
// Affine Binary Operation Expression.
//===----------------------------------------------------------------------===//

/** Returns the left hand side affine expression of the given affine binary
 * operation expression. */
MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr);

/** Returns the right hand side affine expression of the given affine binary
 * operation expression. */
MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr);

#ifdef __cplusplus
}
#endif

#endif // MLIR_C_AFFINEEXPR_H