mlir/include/mlir-c/AffineExpr.h

   1 //===-- mlir-c/AffineExpr.h - C API for MLIR Affine Expressions ---*- C -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
   4 // Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef MLIR_C_AFFINEEXPR_H
  11 #define MLIR_C_AFFINEEXPR_H
  12
  13 #include "mlir-c/IR.h"
  14
  15 #ifdef __cplusplus
  16 extern "C" {
  17 #endif
  18
  19 //===----------------------------------------------------------------------===//
  20 // Opaque type declarations.
  21 //
  22 // Types are exposed to C bindings as structs containing opaque pointers. They
  23 // are not supposed to be inspected from C. This allows the underlying
  24 // representation to change without affecting the API users. The use of structs
  25 // instead of typedefs enables some type safety as structs are not implicitly
  26 // convertible to each other.
  27 //
  28 // Instances of these types may or may not own the underlying object. The
  29 // ownership semantics is defined by how an instance of the type was obtained.
  30 //===----------------------------------------------------------------------===//
  31
  32 #define DEFINE_C_API_STRUCT(name, storage)                                     \
  33   struct name {                                                                \
  34     storage *ptr;                                                              \
  35   };                                                                           \
  36   typedef struct name name
  37
  38 DEFINE_C_API_STRUCT(MlirAffineExpr, const void);
  39
  40 #undef DEFINE_C_API_STRUCT
  41
  42 struct MlirAffineMap;
  43
  44 /// Gets the context that owns the affine expression.
  45 MLIR_CAPI_EXPORTED MlirContext
  46 mlirAffineExprGetContext(MlirAffineExpr affineExpr);
  47
  48 /// Returns `true` if the two affine expressions are equal.
  49 MLIR_CAPI_EXPORTED bool mlirAffineExprEqual(MlirAffineExpr lhs,
  50                                             MlirAffineExpr rhs);
  51
  52 /// Returns `true` if the given affine expression is a null expression. Note
  53 /// constant zero is not a null expression.
  54 inline static bool mlirAffineExprIsNull(MlirAffineExpr affineExpr) {
  55   return affineExpr.ptr == NULL;
  56 }
  57
  58 /// Prints an affine expression by sending chunks of the string representation
  59 /// and forwarding `userData to `callback`. Note that the callback may be called
  60 /// several times with consecutive chunks of the string.
  61 MLIR_CAPI_EXPORTED void mlirAffineExprPrint(MlirAffineExpr affineExpr,
  62                                             MlirStringCallback callback,
  63                                             void *userData);
  64
  65 /// Prints the affine expression to the standard error stream.
  66 MLIR_CAPI_EXPORTED void mlirAffineExprDump(MlirAffineExpr affineExpr);
  67
  68 /// Checks whether the given affine expression is made out of only symbols and
  69 /// constants.
  70 MLIR_CAPI_EXPORTED bool
  71 mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr);
  72
  73 /// Checks whether the given affine expression is a pure affine expression, i.e.
  74 /// mul, floordiv, ceildic, and mod is only allowed w.r.t constants.
  75 MLIR_CAPI_EXPORTED bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
  76
  77 /// Returns the greatest known integral divisor of this affine expression. The
  78 /// result is always positive.
  79 MLIR_CAPI_EXPORTED int64_t
  80 mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr);
  81
  82 /// Checks whether the given affine expression is a multiple of 'factor'.
  83 MLIR_CAPI_EXPORTED bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr,
  84                                                    int64_t factor);
  85
  86 /// Checks whether the given affine expression involves AffineDimExpr
  87 /// 'position'.
  88 MLIR_CAPI_EXPORTED bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
  89                                                       intptr_t position);
  90
  91 /// Composes the given map with the given expression.
  92 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineExprCompose(
  93     MlirAffineExpr affineExpr, struct MlirAffineMap affineMap);
  94
  95 //===----------------------------------------------------------------------===//
  96 // Affine Dimension Expression.
  97 //===----------------------------------------------------------------------===//
  98
  99 /// Checks whether the given affine expression is a dimension expression.
 100 MLIR_CAPI_EXPORTED bool mlirAffineExprIsADim(MlirAffineExpr affineExpr);
 101
 102 /// Creates an affine dimension expression with 'position' in the context.
 103 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx,
 104                                                        intptr_t position);
 105
 106 /// Returns the position of the given affine dimension expression.
 107 MLIR_CAPI_EXPORTED intptr_t
 108 mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr);
 109
 110 //===----------------------------------------------------------------------===//
 111 // Affine Symbol Expression.
 112 //===----------------------------------------------------------------------===//
 113
 114 /// Checks whether the given affine expression is a symbol expression.
 115 MLIR_CAPI_EXPORTED bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr);
 116
 117 /// Creates an affine symbol expression with 'position' in the context.
 118 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx,
 119                                                           intptr_t position);
 120
 121 /// Returns the position of the given affine symbol expression.
 122 MLIR_CAPI_EXPORTED intptr_t
 123 mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr);
 124
 125 //===----------------------------------------------------------------------===//
 126 // Affine Constant Expression.
 127 //===----------------------------------------------------------------------===//
 128
 129 /// Checks whether the given affine expression is a constant expression.
 130 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr);
 131
 132 /// Creates an affine constant expression with 'constant' in the context.
 133 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx,
 134                                                             int64_t constant);
 135
 136 /// Returns the value of the given affine constant expression.
 137 MLIR_CAPI_EXPORTED int64_t
 138 mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr);
 139
 140 //===----------------------------------------------------------------------===//
 141 // Affine Add Expression.
 142 //===----------------------------------------------------------------------===//
 143
 144 /// Checks whether the given affine expression is an add expression.
 145 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);
 146
 147 /// Creates an affine add expression with 'lhs' and 'rhs'.
 148 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs,
 149                                                        MlirAffineExpr rhs);
 150
 151 //===----------------------------------------------------------------------===//
 152 // Affine Mul Expression.
 153 //===----------------------------------------------------------------------===//
 154
 155 /// Checks whether the given affine expression is an mul expression.
 156 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr);
 157
 158 /// Creates an affine mul expression with 'lhs' and 'rhs'.
 159 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs,
 160                                                        MlirAffineExpr rhs);
 161
 162 //===----------------------------------------------------------------------===//
 163 // Affine Mod Expression.
 164 //===----------------------------------------------------------------------===//
 165
 166 /// Checks whether the given affine expression is an mod expression.
 167 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr);
 168
 169 /// Creates an affine mod expression with 'lhs' and 'rhs'.
 170 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs,
 171                                                        MlirAffineExpr rhs);
 172
 173 //===----------------------------------------------------------------------===//
 174 // Affine FloorDiv Expression.
 175 //===----------------------------------------------------------------------===//
 176
 177 /// Checks whether the given affine expression is an floordiv expression.
 178 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);
 179
 180 /// Creates an affine floordiv expression with 'lhs' and 'rhs'.
 181 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
 182                                                             MlirAffineExpr rhs);
 183
 184 //===----------------------------------------------------------------------===//
 185 // Affine CeilDiv Expression.
 186 //===----------------------------------------------------------------------===//
 187
 188 /// Checks whether the given affine expression is an ceildiv expression.
 189 MLIR_CAPI_EXPORTED bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);
 190
 191 /// Creates an affine ceildiv expression with 'lhs' and 'rhs'.
 192 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
 193                                                            MlirAffineExpr rhs);
 194
 195 //===----------------------------------------------------------------------===//
 196 // Affine Binary Operation Expression.
 197 //===----------------------------------------------------------------------===//
 198
 199 /// Checks whether the given affine expression is binary.
 200 MLIR_CAPI_EXPORTED bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr);
 201
 202 /// Returns the left hand side affine expression of the given affine binary
 203 /// operation expression.
 204 MLIR_CAPI_EXPORTED MlirAffineExpr
 205 mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr);
 206
 207 /// Returns the right hand side affine expression of the given affine binary
 208 /// operation expression.
 209 MLIR_CAPI_EXPORTED MlirAffineExpr
 210 mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr);
 211
 212 #ifdef __cplusplus
 213 }
 214 #endif
 215
 216 #endif // MLIR_C_AFFINEEXPR_H