[llvm] [mlir] [mlir][polynomial] Remove polynomial dialect (PR #139766)

via llvm-commits llvm-commits at lists.llvm.org
Tue May 13 10:00:58 PDT 2025


llvmbot wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-mlir

Author: Jeremy Kun (j2kun)

<details>
<summary>Changes</summary>

Cf. https://discourse.llvm.org/t/future-of-the-polynomial-dialect/86117

For posterity, the polynomial dialect development has moved to HEIR, and as of this writing the different components can be found here:

- https://github.com/google/heir/tree/a422f130fa42ed2acf319a1bd6e420b651863c03/lib/Dialect/Polynomial
- https://github.com/google/heir/tree/a422f130fa42ed2acf319a1bd6e420b651863c03/lib/Transforms/PolynomialApproximation
- https://github.com/google/heir/tree/a422f130fa42ed2acf319a1bd6e420b651863c03/lib/Transforms/LowerPolynomialEval

---

Patch is 102.50 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/139766.diff


36 Files Affected:

- (modified) mlir/include/mlir/Dialect/CMakeLists.txt (-1) 
- (removed) mlir/include/mlir/Dialect/Polynomial/CMakeLists.txt (-1) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt (-7) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.h (-282) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td (-350) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.h (-17) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialAttributes.td (-222) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.h (-19) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialDialect.td (-55) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialOps.h (-21) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialTypes.h (-17) 
- (removed) mlir/include/mlir/Dialect/Polynomial/IR/PolynomialTypes.td (-33) 
- (modified) mlir/include/mlir/InitAllDialects.h (+2-4) 
- (modified) mlir/lib/Dialect/CMakeLists.txt (-1) 
- (removed) mlir/lib/Dialect/Polynomial/CMakeLists.txt (-1) 
- (removed) mlir/lib/Dialect/Polynomial/IR/CMakeLists.txt (-26) 
- (removed) mlir/lib/Dialect/Polynomial/IR/Polynomial.cpp (-68) 
- (removed) mlir/lib/Dialect/Polynomial/IR/PolynomialAttributes.cpp (-236) 
- (removed) mlir/lib/Dialect/Polynomial/IR/PolynomialCanonicalization.td (-44) 
- (removed) mlir/lib/Dialect/Polynomial/IR/PolynomialDialect.cpp (-49) 
- (removed) mlir/lib/Dialect/Polynomial/IR/PolynomialOps.cpp (-298) 
- (removed) mlir/test/Dialect/Polynomial/attributes.mlir (-73) 
- (removed) mlir/test/Dialect/Polynomial/canonicalization.mlir (-47) 
- (removed) mlir/test/Dialect/Polynomial/ops.mlir (-112) 
- (removed) mlir/test/Dialect/Polynomial/ops_errors.mlir (-126) 
- (removed) mlir/test/Dialect/Polynomial/types.mlir (-65) 
- (removed) mlir/test/IR/parser_dialect_loading.mlir (-19) 
- (modified) mlir/test/lib/Dialect/Test/CMakeLists.txt (-1) 
- (modified) mlir/test/lib/Dialect/Test/TestAttrDefs.td (-17) 
- (modified) mlir/test/lib/Dialect/Test/TestAttributes.h (+5-5) 
- (modified) mlir/test/lib/Dialect/Test/TestOps.td (-10) 
- (modified) mlir/unittests/Dialect/CMakeLists.txt (-1) 
- (removed) mlir/unittests/Dialect/Polynomial/CMakeLists.txt (-8) 
- (removed) mlir/unittests/Dialect/Polynomial/PolynomialMathTest.cpp (-44) 
- (modified) utils/bazel/llvm-project-overlay/mlir/BUILD.bazel (-91) 
- (modified) utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel (-2) 


``````````diff
diff --git a/mlir/include/mlir/Dialect/CMakeLists.txt b/mlir/include/mlir/Dialect/CMakeLists.txt
index 9d1a840d6644b..56dc97282fa4a 100644
--- a/mlir/include/mlir/Dialect/CMakeLists.txt
+++ b/mlir/include/mlir/Dialect/CMakeLists.txt
@@ -28,7 +28,6 @@ add_subdirectory(OpenACCMPCommon)
 add_subdirectory(OpenMP)
 add_subdirectory(PDL)
 add_subdirectory(PDLInterp)
-add_subdirectory(Polynomial)
 add_subdirectory(Ptr)
 add_subdirectory(Quant)
 add_subdirectory(SCF)
diff --git a/mlir/include/mlir/Dialect/Polynomial/CMakeLists.txt b/mlir/include/mlir/Dialect/Polynomial/CMakeLists.txt
deleted file mode 100644
index f33061b2d87cf..0000000000000
--- a/mlir/include/mlir/Dialect/Polynomial/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-add_subdirectory(IR)
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt b/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
deleted file mode 100644
index ecdea158ddefb..0000000000000
--- a/mlir/include/mlir/Dialect/Polynomial/IR/CMakeLists.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-add_mlir_dialect(Polynomial polynomial)
-add_mlir_doc(Polynomial PolynomialDialect Dialects/ -gen-dialect-doc -dialect=polynomial)
-
-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.h b/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.h
deleted file mode 100644
index 8d7f1436fdc60..0000000000000
--- a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.h
+++ /dev/null
@@ -1,282 +0,0 @@
-//===- Polynomial.h - A data class for polynomials --------------*- 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_DIALECT_POLYNOMIAL_IR_POLYNOMIAL_H_
-#define MLIR_DIALECT_POLYNOMIAL_IR_POLYNOMIAL_H_
-
-#include "mlir/Support/LLVM.h"
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/Twine.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace mlir {
-
-class MLIRContext;
-
-namespace polynomial {
-
-/// This restricts statically defined polynomials to have at most 64-bit
-/// coefficients. This may be relaxed in the future, but it seems unlikely one
-/// would want to specify 128-bit polynomials statically in the source code.
-constexpr unsigned apintBitWidth = 64;
-
-template <class Derived, typename CoefficientType>
-class MonomialBase {
-public:
-  MonomialBase(const CoefficientType &coeff, const APInt &expo)
-      : coefficient(coeff), exponent(expo) {}
-  virtual ~MonomialBase() = default;
-
-  const CoefficientType &getCoefficient() const { return coefficient; }
-  CoefficientType &getMutableCoefficient() { return coefficient; }
-  const APInt &getExponent() const { return exponent; }
-  void setCoefficient(const CoefficientType &coeff) { coefficient = coeff; }
-  void setExponent(const APInt &exp) { exponent = exp; }
-
-  bool operator==(const MonomialBase &other) const {
-    return other.coefficient == coefficient && other.exponent == exponent;
-  }
-  bool operator!=(const MonomialBase &other) const {
-    return other.coefficient != coefficient || other.exponent != exponent;
-  }
-
-  /// Monomials are ordered by exponent.
-  bool operator<(const MonomialBase &other) const {
-    return (exponent.ult(other.exponent));
-  }
-
-  Derived add(const Derived &other) {
-    assert(exponent == other.exponent);
-    CoefficientType newCoeff = coefficient + other.coefficient;
-    Derived result;
-    result.setCoefficient(newCoeff);
-    result.setExponent(exponent);
-    return result;
-  }
-
-  virtual bool isMonic() const = 0;
-  virtual void
-  coefficientToString(llvm::SmallString<16> &coeffString) const = 0;
-
-  template <class D, typename T>
-  friend ::llvm::hash_code hash_value(const MonomialBase<D, T> &arg);
-
-protected:
-  CoefficientType coefficient;
-  APInt exponent;
-};
-
-/// A class representing a monomial of a single-variable polynomial with integer
-/// coefficients.
-class IntMonomial : public MonomialBase<IntMonomial, APInt> {
-public:
-  IntMonomial(int64_t coeff, uint64_t expo)
-      : MonomialBase(APInt(apintBitWidth, coeff), APInt(apintBitWidth, expo)) {}
-
-  IntMonomial()
-      : MonomialBase(APInt(apintBitWidth, 0), APInt(apintBitWidth, 0)) {}
-
-  ~IntMonomial() override = default;
-
-  bool isMonic() const override { return coefficient == 1; }
-
-  void coefficientToString(llvm::SmallString<16> &coeffString) const override {
-    coefficient.toStringSigned(coeffString);
-  }
-};
-
-/// A class representing a monomial of a single-variable polynomial with integer
-/// coefficients.
-class FloatMonomial : public MonomialBase<FloatMonomial, APFloat> {
-public:
-  FloatMonomial(double coeff, uint64_t expo)
-      : MonomialBase(APFloat(coeff), APInt(apintBitWidth, expo)) {}
-
-  FloatMonomial() : MonomialBase(APFloat((double)0), APInt(apintBitWidth, 0)) {}
-
-  ~FloatMonomial() override = default;
-
-  bool isMonic() const override { return coefficient == APFloat(1.0); }
-
-  void coefficientToString(llvm::SmallString<16> &coeffString) const override {
-    coefficient.toString(coeffString);
-  }
-};
-
-template <class Derived, typename Monomial>
-class PolynomialBase {
-public:
-  PolynomialBase() = delete;
-
-  explicit PolynomialBase(ArrayRef<Monomial> terms) : terms(terms) {};
-
-  explicit operator bool() const { return !terms.empty(); }
-  bool operator==(const PolynomialBase &other) const {
-    return other.terms == terms;
-  }
-  bool operator!=(const PolynomialBase &other) const {
-    return !(other.terms == terms);
-  }
-
-  void print(raw_ostream &os, ::llvm::StringRef separator,
-             ::llvm::StringRef exponentiation) const {
-    bool first = true;
-    for (const Monomial &term : getTerms()) {
-      if (first) {
-        first = false;
-      } else {
-        os << separator;
-      }
-      std::string coeffToPrint;
-      if (term.isMonic() && term.getExponent().uge(1)) {
-        coeffToPrint = "";
-      } else {
-        llvm::SmallString<16> coeffString;
-        term.coefficientToString(coeffString);
-        coeffToPrint = coeffString.str();
-      }
-
-      if (term.getExponent() == 0) {
-        os << coeffToPrint;
-      } else if (term.getExponent() == 1) {
-        os << coeffToPrint << "x";
-      } else {
-        llvm::SmallString<16> expString;
-        term.getExponent().toStringSigned(expString);
-        os << coeffToPrint << "x" << exponentiation << expString;
-      }
-    }
-  }
-
-  Derived add(const Derived &other) {
-    SmallVector<Monomial> newTerms;
-    auto it1 = terms.begin();
-    auto it2 = other.terms.begin();
-    while (it1 != terms.end() || it2 != other.terms.end()) {
-      if (it1 == terms.end()) {
-        newTerms.emplace_back(*it2);
-        it2++;
-        continue;
-      }
-
-      if (it2 == other.terms.end()) {
-        newTerms.emplace_back(*it1);
-        it1++;
-        continue;
-      }
-
-      while (it1->getExponent().ult(it2->getExponent())) {
-        newTerms.emplace_back(*it1);
-        it1++;
-        if (it1 == terms.end())
-          break;
-      }
-
-      while (it2->getExponent().ult(it1->getExponent())) {
-        newTerms.emplace_back(*it2);
-        it2++;
-        if (it2 == terms.end())
-          break;
-      }
-
-      newTerms.emplace_back(it1->add(*it2));
-      it1++;
-      it2++;
-    }
-    return Derived(newTerms);
-  }
-
-  // Prints polynomial to 'os'.
-  void print(raw_ostream &os) const { print(os, " + ", "**"); }
-
-  void dump() const;
-
-  // Prints polynomial so that it can be used as a valid identifier
-  std::string toIdentifier() const {
-    std::string result;
-    llvm::raw_string_ostream os(result);
-    print(os, "_", "");
-    return os.str();
-  }
-
-  unsigned getDegree() const {
-    return terms.back().getExponent().getZExtValue();
-  }
-
-  ArrayRef<Monomial> getTerms() const { return terms; }
-
-  template <class D, typename T>
-  friend ::llvm::hash_code hash_value(const PolynomialBase<D, T> &arg);
-
-private:
-  // The monomial terms for this polynomial.
-  SmallVector<Monomial> terms;
-};
-
-/// A single-variable polynomial with integer coefficients.
-///
-/// Eg: x^1024 + x + 1
-class IntPolynomial : public PolynomialBase<IntPolynomial, IntMonomial> {
-public:
-  explicit IntPolynomial(ArrayRef<IntMonomial> terms) : PolynomialBase(terms) {}
-
-  // Returns a Polynomial from a list of monomials.
-  // Fails if two monomials have the same exponent.
-  static FailureOr<IntPolynomial>
-  fromMonomials(ArrayRef<IntMonomial> monomials);
-
-  /// Returns a polynomial with coefficients given by `coeffs`. The value
-  /// coeffs[i] is converted to a monomial with exponent i.
-  static IntPolynomial fromCoefficients(ArrayRef<int64_t> coeffs);
-};
-
-/// A single-variable polynomial with double coefficients.
-///
-/// Eg: 1.0 x^1024 + 3.5 x + 1e-05
-class FloatPolynomial : public PolynomialBase<FloatPolynomial, FloatMonomial> {
-public:
-  explicit FloatPolynomial(ArrayRef<FloatMonomial> terms)
-      : PolynomialBase(terms) {}
-
-  // Returns a Polynomial from a list of monomials.
-  // Fails if two monomials have the same exponent.
-  static FailureOr<FloatPolynomial>
-  fromMonomials(ArrayRef<FloatMonomial> monomials);
-
-  /// Returns a polynomial with coefficients given by `coeffs`. The value
-  /// coeffs[i] is converted to a monomial with exponent i.
-  static FloatPolynomial fromCoefficients(ArrayRef<double> coeffs);
-};
-
-// Make Polynomials hashable.
-template <class D, typename T>
-inline ::llvm::hash_code hash_value(const PolynomialBase<D, T> &arg) {
-  return ::llvm::hash_combine_range(arg.terms);
-}
-
-template <class D, typename T>
-inline ::llvm::hash_code hash_value(const MonomialBase<D, T> &arg) {
-  return llvm::hash_combine(::llvm::hash_value(arg.coefficient),
-                            ::llvm::hash_value(arg.exponent));
-}
-
-template <class D, typename T>
-inline raw_ostream &operator<<(raw_ostream &os,
-                               const PolynomialBase<D, T> &polynomial) {
-  polynomial.print(os);
-  return os;
-}
-
-} // namespace polynomial
-} // namespace mlir
-
-#endif // MLIR_DIALECT_POLYNOMIAL_IR_POLYNOMIAL_H_
diff --git a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td b/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
deleted file mode 100644
index 755396c8b9023..0000000000000
--- a/mlir/include/mlir/Dialect/Polynomial/IR/Polynomial.td
+++ /dev/null
@@ -1,350 +0,0 @@
-//===- Polynomial.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_OPS
-#define POLYNOMIAL_OPS
-
-include "mlir/IR/BuiltinAttributes.td"
-include "mlir/IR/OpBase.td"
-include "mlir/Interfaces/InferTypeOpInterface.td"
-include "mlir/Interfaces/SideEffectInterfaces.td"
-include "mlir/Dialect/Polynomial/IR/PolynomialDialect.td"
-include "mlir/Dialect/Polynomial/IR/PolynomialAttributes.td"
-include "mlir/Dialect/Polynomial/IR/PolynomialTypes.td"
-
-class Polynomial_Op<string mnemonic, list<Trait> traits = []> :
-    Op<Polynomial_Dialect, mnemonic, traits # [Pure]> {
-  let assemblyFormat = "operands attr-dict `:` functional-type(operands, results)";
-}
-
-class Polynomial_UnaryOp<string mnemonic, list<Trait> traits = []> :
-    Polynomial_Op<mnemonic, traits # [SameOperandsAndResultType]> {
-  let arguments = (ins Polynomial_PolynomialType:$operand);
-  let results = (outs Polynomial_PolynomialType:$result);
-}
-
-class Polynomial_BinaryOp<string mnemonic, list<Trait> traits = []> :
-    Polynomial_Op<mnemonic, !listconcat(traits, [Pure, SameOperandsAndResultType, ElementwiseMappable])> {
-  let arguments = (ins PolynomialLike:$lhs, PolynomialLike:$rhs);
-  let results = (outs PolynomialLike:$result);
-  let assemblyFormat = "operands attr-dict `:` type($result)";
-}
-
-def Polynomial_AddOp : Polynomial_BinaryOp<"add", [Commutative]> {
-  let summary = "Addition operation between polynomials.";
-  let description = [{
-    Performs polynomial addition on the operands. The operands may be single
-    polynomials or containers of identically-typed polynomials, i.e., polynomials
-    from the same underlying ring with the same coefficient types.
-
-    Addition is defined to occur in the ring defined by the ring attribute of
-    the two operands, meaning the addition is taken modulo the coefficientModulus
-    and the polynomialModulus of the ring.
-
-    Example:
-
-    ```mlir
-    // add two polynomials modulo x^1024 - 1
-    #poly = #polynomial.int_polynomial<x**1024 - 1>
-    #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=65536:i32, polynomialModulus=#poly>
-    %0 = polynomial.constant int<1 + x**2> : !polynomial.polynomial<#ring>
-    %1 = polynomial.constant int<x**5 - x + 1> : !polynomial.polynomial<#ring>
-    %2 = polynomial.add %0, %1 : !polynomial.polynomial<#ring>
-    ```
-  }];
-}
-
-def Polynomial_SubOp : Polynomial_BinaryOp<"sub"> {
-  let summary = "Subtraction operation between polynomials.";
-  let description = [{
-    Performs polynomial subtraction on the operands. The operands may be single
-    polynomials or containers of identically-typed polynomials, i.e., polynomials
-    from the same underlying ring with the same coefficient types.
-
-    Subtraction is defined to occur in the ring defined by the ring attribute of
-    the two operands, meaning the subtraction is taken modulo the coefficientModulus
-    and the polynomialModulus of the ring.
-
-    Example:
-
-    ```mlir
-    // subtract two polynomials modulo x^1024 - 1
-    #poly = #polynomial.int_polynomial<x**1024 - 1>
-    #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=65536:i32, polynomialModulus=#poly>
-    %0 = polynomial.constant int<1 + x**2> : !polynomial.polynomial<#ring>
-    %1 = polynomial.constant int<x**5 - x + 1> : !polynomial.polynomial<#ring>
-    %2 = polynomial.sub %0, %1 : !polynomial.polynomial<#ring>
-    ```
-  }];
-  let hasCanonicalizer = 1;
-}
-
-def Polynomial_MulOp : Polynomial_BinaryOp<"mul", [Commutative]> {
-  let summary = "Multiplication operation between polynomials.";
-  let description = [{
-    Performs polynomial multiplication on the operands. The operands may be single
-    polynomials or containers of identically-typed polynomials, i.e., polynomials
-    from the same underlying ring with the same coefficient types.
-
-    Multiplication is defined to occur in the ring defined by the ring attribute of
-    the two operands, meaning the multiplication is taken modulo the coefficientModulus
-    and the polynomialModulus of the ring.
-
-    Example:
-
-    ```mlir
-    // multiply two polynomials modulo x^1024 - 1
-    #poly = #polynomial.int_polynomial<x**1024 - 1>
-    #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=65536:i32, polynomialModulus=#poly>
-    %0 = polynomial.constant int<1 + x**2> : !polynomial.polynomial<#ring>
-    %1 = polynomial.constant int<x**5 - x + 1> : !polynomial.polynomial<#ring>
-    %2 = polynomial.mul %0, %1 : !polynomial.polynomial<#ring>
-    ```
-  }];
-}
-
-def Polynomial_MulScalarOp : Polynomial_Op<"mul_scalar", [
-      ElementwiseMappable, AllTypesMatch<["polynomial", "output"]>]> {
-  let summary = "Multiplication by a scalar of the field.";
-  let description = [{
-    Multiplies the polynomial operand's coefficients by a given scalar value.
-    The operation is defined to occur in the ring defined by the ring attribute
-    of the two operands, meaning the multiplication is taken modulo the
-    coefficientModulus of the ring.
-
-    The `scalar` input must have the same type as the polynomial ring's
-    coefficientType.
-
-    Example:
-
-    ```mlir
-    // multiply two polynomials modulo x^1024 - 1
-    #poly = #polynomial.int_polynomial<x**1024 - 1>
-    #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=65536:i32, polynomialModulus=#poly>
-    %0 = polynomial.constant int<1 + x**2> : !polynomial.polynomial<#ring>
-    %1 = arith.constant 3 : i32
-    %2 = polynomial.mul_scalar %0, %1 : !polynomial.polynomial<#ring>, i32
-    ```
-  }];
-
-  let arguments = (ins
-    PolynomialLike:$polynomial,
-    AnyInteger:$scalar
-  );
-  let results = (outs
-    PolynomialLike:$output
-  );
-  let assemblyFormat = "operands attr-dict `:` type($polynomial) `,` type($scalar)";
-  let hasVerifier = 1;
-}
-
-def Polynomial_LeadingTermOp: Polynomial_Op<"leading_term"> {
-  let summary = "Compute the leading term of the polynomial.";
-  let description = [{
-    The degree of a polynomial is the largest $k$ for which the coefficient
-    `a_k` of `x^k` is nonzero. The leading term is the term `a_k * x^k`, which
-    this op represents as a pair of results. The first is the degree `k` as an
-    index, and the second is the coefficient, whose type matches the
-    coefficient type of the polynomial's ring attribute.
-
-    Example:
-
-    ```mlir
-    #poly = #polynomial.int_polynomial<x**1024 - 1>
-    #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=65536:i32, polynomialModulus=#poly>
-    %0 = polynomial.constant int<1 + x**2> : !polynomial.polynomial<#ring>
-    %1, %2 = polynomial.leading_term %0 : !polynomial.polynomial<#ring> -> (index, i32)
-    ```
-  }];
-  let arguments = (ins Polynomial_PolynomialType:$input);
-  let results = (outs Index:$degree, AnyInteger:$coefficient);
-  let assemblyFormat = "operands attr-dict `:` type($input) `->` `(` type($degree) `,` type($coefficient) `)`";
-}
-
-def Polynomial_MonomialOp: Polynomial_Op<"monomial"> {
-  let summary = "Create a polynomial that consists of a single monomial.";
-  let description = [{
-    Construct a polynomial that consists of a single monomial term, from its
-    degree and coefficient as dynamic inputs.
-
-    The coefficient type of the output polynomial's ring attribute must match
-    the `coefficient` input type.
-
-    Example:
-
-    ```mlir
-    #poly = #polynomial.int_polynomial<x**1024 - 1>
-    #ring = #polynomial.ring<coefficientType=i32, coefficientModulus=65536:i32, polynomialModulus=#poly>
-    %deg = arith.constant 1023 : index
-    %five = arith.constant 5 : i32
-    %0 = polynomial.monomial %five, %deg : (i32, index) -> !polynomial.polynomial<#ring>
-    ```
-  }];
-  let arguments = (ins AnyInteger:$coefficient, Index:$degree);
-  let results = (outs Polynomial_PolynomialType:$output);
-}
-
-def Polynomial_MonicMonomialMulOp: Polynomial_Op<"monic_monomial_mul", [AllTypesMatch<["input", "output"]>]> {
-  let summary = "Multiply a polynomial by a monic monomial.";
-  let description = [{
-    Multiply a polynomial by a monic monomial, meaning a polynomial of the form
-    `1 * x^k` for an index operand `k`.
-
-    In some special rings of polynomials, such as a ring of polynomials
-    modulo `x^n - 1`, `monomial_mul` can be interpreted as a cyclic shift of
-    the coefficients of the polynomial. For some rings, this results in
-    optimized lowerings that involve rotations and rescaling of the
-    coefficients of the input.
-  }];
-  let arguments = (ins PolynomialLike:$input, Index:$monomialDegree);
-  let results = (outs PolynomialLike:$output);
-}
-
-def Polynomial_FromTensorOp : Polynomial_Op<"from_tensor", [Pure]> {
-  let summary = "Creates a polynomial from integer coefficients stored in a tensor.";
-  let description = [{
-    `polynomial.from_tensor` creates a polynomial value from a tensor of coefficients.
-    The input tensor must list the coefficients in degree-increasing order.
-
-    The input one-dimensional tensor may have size at most the degree of the
-    ring's polynomialModulus generator polynomial, with smaller dimension implying that
-    all higher-degree t...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/139766


More information about the llvm-commits mailing list