[Mlir-commits] [llvm] [mlir] [mlir][polynomial] split attributes into its own tablegen (PR #92613)
Jeremy Kun
llvmlistbot at llvm.org
Fri May 17 15:41:46 PDT 2024
https://github.com/j2kun created https://github.com/llvm/llvm-project/pull/92613
Out of tree we have other dialects that use the ring attribute, but we get compilation errors when generating ops while pulling in all the Polynomial tablegen ops (there's no `-dialect` flag in `mlir-tblgen` for op generation like there is for attributes and types).
This PR simply moves the attributes into its own file, so it can be included separately, and this also requires moving the dialect declaration into its own file.
>From ebebe214a1f203a1d0806ac3b99852ee1277af28 Mon Sep 17 00:00:00 2001
From: Jeremy Kun <jkun at google.com>
Date: Fri, 17 May 2024 15:39:48 -0700
Subject: [PATCH] [mlir][polynomial] split attribute tablegen
---
.../mlir/Dialect/Polynomial/IR/CMakeLists.txt | 2 +-
.../mlir/Dialect/Polynomial/IR/Polynomial.td | 153 +-----------------
.../Polynomial/IR/PolynomialAttributes.td | 125 ++++++++++++++
.../Polynomial/IR/PolynomialDialect.td | 55 +++++++
.../llvm-project-overlay/mlir/BUILD.bazel | 2 +-
5 files changed, 184 insertions(+), 153 deletions(-)
create mode 100644 mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td
create mode 100644 mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt b/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
index e8f48f13be2b8..ecdea158ddefb 100644
--- a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
@@ -1,7 +1,7 @@
add_mlir_dialect(Polynomial polynomial)
add_mlir_doc(Polynomial PolynomialDialect Dialects/ -gen-dialect-doc -dialect=polynomial)
-set(LLVM_TARGET_DEFINITIONS Polynomial.td)
+set(LLVM_TARGET_DEFINITIONS PolynomialAttributes.td)
mlir_tablegen(PolynomialAttributes.cpp.inc -gen-attrdef-defs -attrdefs-dialect=polynomial)
mlir_tablegen(PolynomialAttributes.h.inc -gen-attrdef-decls -attrdefs-dialect=polynomial)
add_public_tablegen_target(MLIRPolynomialAttributesIncGen)
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td b/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
index 537be4832e8f8..294f58ae084bf 100644
--- a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
@@ -13,157 +13,8 @@ include "mlir/IR/BuiltinAttributes.td"
include "mlir/IR/OpBase.td"
include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td"
-
-def Polynomial_Dialect : Dialect {
- let name = "polynomial";
- let cppNamespace = "::mlir::polynomial";
- let description = [{
- The Polynomial dialect defines single-variable polynomial types and
- operations.
-
- The simplest use of `polynomial` is to represent mathematical operations in
- a polynomial ring `R[x]`, where `R` is another MLIR type like `i32`.
-
- More generally, this dialect supports representing polynomial operations in a
- quotient ring `R[X]/(f(x))` for some statically fixed polynomial `f(x)`.
- Two polyomials `p(x), q(x)` are considered equal in this ring if they have the
- same remainder when dividing by `f(x)`. When a modulus is given, ring operations
- are performed with reductions modulo `f(x)` and relative to the coefficient ring
- `R`.
-
- Examples:
-
- ```mlir
- // A constant polynomial in a ring with i32 coefficients and no polynomial modulus
- #ring = #polynomial.ring<coefficientType=i32>
- %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
-
- // A constant polynomial in a ring with i32 coefficients, modulo (x^1024 + 1)
- #modulus = #polynomial.int_polynomial<1 + x**1024>
- #ring = #polynomial.ring<coefficientType=i32, polynomialModulus=#modulus>
- %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
-
- // A constant polynomial in a ring with i32 coefficients, with a polynomial
- // modulus of (x^1024 + 1) and a coefficient modulus of 17.
- #modulus = #polynomial.int_polynomial<1 + x**1024>
- #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=17:i32, polynomialModulus=#modulus>
- %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
- ```
- }];
-
- let useDefaultTypePrinterParser = 1;
- let useDefaultAttributePrinterParser = 1;
-}
-
-class Polynomial_Attr<string name, string attrMnemonic, list<Trait> traits = []>
- : AttrDef<Polynomial_Dialect, name, traits> {
- let mnemonic = attrMnemonic;
-}
-
-def Polynomial_IntPolynomialAttr : Polynomial_Attr<"IntPolynomial", "int_polynomial"> {
- let summary = "An attribute containing a single-variable polynomial with integer coefficients.";
- let description = [{
- A polynomial attribute represents a single-variable polynomial with integer
- coefficients, which is used to define the modulus of a `RingAttr`, as well
- as to define constants and perform constant folding for `polynomial` ops.
-
- The polynomial must be expressed as a list of monomial terms, with addition
- or subtraction between them. The choice of variable name is arbitrary, but
- must be consistent across all the monomials used to define a single
- attribute. The order of monomial terms is arbitrary, each monomial degree
- must occur at most once.
-
- Example:
-
- ```mlir
- #poly = #polynomial.int_polynomial<x**1024 + 1>
- ```
- }];
- let parameters = (ins "::mlir::polynomial::IntPolynomial":$polynomial);
- let hasCustomAssemblyFormat = 1;
-}
-
-def Polynomial_FloatPolynomialAttr : Polynomial_Attr<"FloatPolynomial", "float_polynomial"> {
- let summary = "An attribute containing a single-variable polynomial with double precision floating point coefficients.";
- let description = [{
- A polynomial attribute represents a single-variable polynomial with double
- precision floating point coefficients.
-
- The polynomial must be expressed as a list of monomial terms, with addition
- or subtraction between them. The choice of variable name is arbitrary, but
- must be consistent across all the monomials used to define a single
- attribute. The order of monomial terms is arbitrary, each monomial degree
- must occur at most once.
-
- Example:
-
- ```mlir
- #poly = #polynomial.float_polynomial<0.5 x**7 + 1.5>
- ```
- }];
- let parameters = (ins "FloatPolynomial":$polynomial);
- let hasCustomAssemblyFormat = 1;
-}
-
-def Polynomial_RingAttr : Polynomial_Attr<"Ring", "ring"> {
- let summary = "An attribute specifying a polynomial ring.";
- let description = [{
- A ring describes the domain in which polynomial arithmetic occurs. The ring
- attribute in `polynomial` represents the more specific case of polynomials
- with a single indeterminate; whose coefficients can be represented by
- another MLIR type (`coefficientType`); and, if the coefficient type is
- integral, whose coefficients are taken modulo some statically known modulus
- (`coefficientModulus`).
-
- Additionally, a polynomial ring can specify a _polynomialModulus_, which converts
- polynomial arithmetic to the analogue of modular integer arithmetic, where
- each polynomial is represented as its remainder when dividing by the
- modulus. For single-variable polynomials, an "polynomialModulus" is always specificed
- via a single polynomial, which we call `polynomialModulus`.
-
- An expressive example is polynomials with i32 coefficients, whose
- coefficients are taken modulo `2**32 - 5`, with a polynomial modulus of
- `x**1024 - 1`.
-
- ```mlir
- #poly_mod = #polynomial.int_polynomial<-1 + x**1024>
- #ring = #polynomial.ring<coefficientType=i32,
- coefficientModulus=4294967291:i32,
- polynomialModulus=#poly_mod>
-
- %0 = ... : polynomial.polynomial<#ring>
- ```
-
- In this case, the value of a polynomial is always "converted" to a
- canonical form by applying repeated reductions by setting `x**1024 = 1`
- and simplifying.
-
- The coefficient and polynomial modulus parameters are optional, and the
- coefficient modulus is only allowed if the coefficient type is integral.
- }];
-
- let parameters = (ins
- "Type": $coefficientType,
- OptionalParameter<"::mlir::IntegerAttr">: $coefficientModulus,
- OptionalParameter<"::mlir::polynomial::IntPolynomialAttr">: $polynomialModulus,
- OptionalParameter<"::mlir::IntegerAttr">: $primitiveRoot
- );
- let assemblyFormat = "`<` struct(params) `>`";
- let builders = [
- AttrBuilderWithInferredContext<
- (ins "::mlir::Type":$coefficientTy,
- CArg<"::mlir::IntegerAttr", "nullptr"> :$coefficientModulusAttr,
- CArg<"::mlir::polynomial::IntPolynomialAttr", "nullptr"> :$polynomialModulusAttr,
- CArg<"::mlir::IntegerAttr", "nullptr"> :$primitiveRootAttr), [{
- return $_get(
- coefficientTy.getContext(),
- coefficientTy,
- coefficientModulusAttr,
- polynomialModulusAttr,
- primitiveRootAttr);
- }]>,
- ];
-}
+include "mlir/Dialect/Polynomial/IR/PolynomialDialect.td"
+include "mlir/Dialect/Polynomial/IR/PolynomialAttributes.td"
class Polynomial_Type<string name, string typeMnemonic>
: TypeDef<Polynomial_Dialect, name> {
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td
new file mode 100644
index 0000000000000..e5dbfa7fa21ee
--- /dev/null
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td
@@ -0,0 +1,125 @@
+//===- PolynomialOps.td - Polynomial dialect ---------------*- tablegen -*-===//
+//
+// 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 POLYNOMIAL_ATTRIBUTES
+#define POLYNOMIAL_ATTRIBUTES
+
+include "mlir/IR/BuiltinAttributes.td"
+include "mlir/Dialect/Polynomial/IR/PolynomialDialect.td"
+
+class Polynomial_Attr<string name, string attrMnemonic, list<Trait> traits = []>
+ : AttrDef<Polynomial_Dialect, name, traits> {
+ let mnemonic = attrMnemonic;
+}
+
+def Polynomial_IntPolynomialAttr : Polynomial_Attr<"IntPolynomial", "int_polynomial"> {
+ let summary = "An attribute containing a single-variable polynomial with integer coefficients.";
+ let description = [{
+ A polynomial attribute represents a single-variable polynomial with integer
+ coefficients, which is used to define the modulus of a `RingAttr`, as well
+ as to define constants and perform constant folding for `polynomial` ops.
+
+ The polynomial must be expressed as a list of monomial terms, with addition
+ or subtraction between them. The choice of variable name is arbitrary, but
+ must be consistent across all the monomials used to define a single
+ attribute. The order of monomial terms is arbitrary, each monomial degree
+ must occur at most once.
+
+ Example:
+
+ ```mlir
+ #poly = #polynomial.int_polynomial<x**1024 + 1>
+ ```
+ }];
+ let parameters = (ins "::mlir::polynomial::IntPolynomial":$polynomial);
+ let hasCustomAssemblyFormat = 1;
+}
+
+def Polynomial_FloatPolynomialAttr : Polynomial_Attr<"FloatPolynomial", "float_polynomial"> {
+ let summary = "An attribute containing a single-variable polynomial with double precision floating point coefficients.";
+ let description = [{
+ A polynomial attribute represents a single-variable polynomial with double
+ precision floating point coefficients.
+
+ The polynomial must be expressed as a list of monomial terms, with addition
+ or subtraction between them. The choice of variable name is arbitrary, but
+ must be consistent across all the monomials used to define a single
+ attribute. The order of monomial terms is arbitrary, each monomial degree
+ must occur at most once.
+
+ Example:
+
+ ```mlir
+ #poly = #polynomial.float_polynomial<0.5 x**7 + 1.5>
+ ```
+ }];
+ let parameters = (ins "FloatPolynomial":$polynomial);
+ let hasCustomAssemblyFormat = 1;
+}
+
+def Polynomial_RingAttr : Polynomial_Attr<"Ring", "ring"> {
+ let summary = "An attribute specifying a polynomial ring.";
+ let description = [{
+ A ring describes the domain in which polynomial arithmetic occurs. The ring
+ attribute in `polynomial` represents the more specific case of polynomials
+ with a single indeterminate; whose coefficients can be represented by
+ another MLIR type (`coefficientType`); and, if the coefficient type is
+ integral, whose coefficients are taken modulo some statically known modulus
+ (`coefficientModulus`).
+
+ Additionally, a polynomial ring can specify a _polynomialModulus_, which converts
+ polynomial arithmetic to the analogue of modular integer arithmetic, where
+ each polynomial is represented as its remainder when dividing by the
+ modulus. For single-variable polynomials, an "polynomialModulus" is always specificed
+ via a single polynomial, which we call `polynomialModulus`.
+
+ An expressive example is polynomials with i32 coefficients, whose
+ coefficients are taken modulo `2**32 - 5`, with a polynomial modulus of
+ `x**1024 - 1`.
+
+ ```mlir
+ #poly_mod = #polynomial.int_polynomial<-1 + x**1024>
+ #ring = #polynomial.ring<coefficientType=i32,
+ coefficientModulus=4294967291:i32,
+ polynomialModulus=#poly_mod>
+
+ %0 = ... : polynomial.polynomial<#ring>
+ ```
+
+ In this case, the value of a polynomial is always "converted" to a
+ canonical form by applying repeated reductions by setting `x**1024 = 1`
+ and simplifying.
+
+ The coefficient and polynomial modulus parameters are optional, and the
+ coefficient modulus is only allowed if the coefficient type is integral.
+ }];
+
+ let parameters = (ins
+ "Type": $coefficientType,
+ OptionalParameter<"::mlir::IntegerAttr">: $coefficientModulus,
+ OptionalParameter<"::mlir::polynomial::IntPolynomialAttr">: $polynomialModulus,
+ OptionalParameter<"::mlir::IntegerAttr">: $primitiveRoot
+ );
+ let assemblyFormat = "`<` struct(params) `>`";
+ let builders = [
+ AttrBuilderWithInferredContext<
+ (ins "::mlir::Type":$coefficientTy,
+ CArg<"::mlir::IntegerAttr", "nullptr"> :$coefficientModulusAttr,
+ CArg<"::mlir::polynomial::IntPolynomialAttr", "nullptr"> :$polynomialModulusAttr,
+ CArg<"::mlir::IntegerAttr", "nullptr"> :$primitiveRootAttr), [{
+ return $_get(
+ coefficientTy.getContext(),
+ coefficientTy,
+ coefficientModulusAttr,
+ polynomialModulusAttr,
+ primitiveRootAttr);
+ }]>,
+ ];
+}
+
+#endif // POLYNOMIAL_ATTRIBUTES
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td
new file mode 100644
index 0000000000000..b0573b3715f78
--- /dev/null
+++ b/mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td
@@ -0,0 +1,55 @@
+//===- PolynomialDialect.td - Polynomial dialect base ------*- tablegen -*-===//
+//
+// 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 POLYNOMIAL_DIALECT
+#define POLYNOMIAL_DIALECT
+
+include "mlir/IR/OpBase.td"
+
+def Polynomial_Dialect : Dialect {
+ let name = "polynomial";
+ let cppNamespace = "::mlir::polynomial";
+ let description = [{
+ The Polynomial dialect defines single-variable polynomial types and
+ operations.
+
+ The simplest use of `polynomial` is to represent mathematical operations in
+ a polynomial ring `R[x]`, where `R` is another MLIR type like `i32`.
+
+ More generally, this dialect supports representing polynomial operations in a
+ quotient ring `R[X]/(f(x))` for some statically fixed polynomial `f(x)`.
+ Two polyomials `p(x), q(x)` are considered equal in this ring if they have the
+ same remainder when dividing by `f(x)`. When a modulus is given, ring operations
+ are performed with reductions modulo `f(x)` and relative to the coefficient ring
+ `R`.
+
+ Examples:
+
+ ```mlir
+ // A constant polynomial in a ring with i32 coefficients and no polynomial modulus
+ #ring = #polynomial.ring<coefficientType=i32>
+ %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
+
+ // A constant polynomial in a ring with i32 coefficients, modulo (x^1024 + 1)
+ #modulus = #polynomial.int_polynomial<1 + x**1024>
+ #ring = #polynomial.ring<coefficientType=i32, polynomialModulus=#modulus>
+ %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
+
+ // A constant polynomial in a ring with i32 coefficients, with a polynomial
+ // modulus of (x^1024 + 1) and a coefficient modulus of 17.
+ #modulus = #polynomial.int_polynomial<1 + x**1024>
+ #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=17:i32, polynomialModulus=#modulus>
+ %a = polynomial.constant <1 + x**2 - 3x**3> : polynomial.polynomial<#ring>
+ ```
+ }];
+
+ let useDefaultTypePrinterParser = 1;
+ let useDefaultAttributePrinterParser = 1;
+}
+
+#endif // POLYNOMIAL_OPS
diff --git a/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel b/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel
index dac759cfd1002..71fca298e9b9a 100644
--- a/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel
+++ b/utils/bazel/llvm-project-overlay/mlir/BUILD.bazel
@@ -6737,7 +6737,7 @@ cc_library(
td_library(
name = "PolynomialTdFiles",
- srcs = ["include/mlir/Dialect/Polynomial/IR/Polynomial.td"],
+ srcs = glob(["include/mlir/Dialect/Polynomial/IR/*.td"]),
includes = ["include"],
deps = [
":BuiltinDialectTdFiles",
More information about the Mlir-commits
mailing list