[Mlir-commits] [mlir] Revert "[MLIR] Add `IntegerDivisibilityAnalysis` and `InferIntDivisibilityOpInterface`" (PR #198048)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Fri May 15 17:24:15 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir-arith
@llvm/pr-subscribers-mlir
Author: Kewen Meng (Kewen12)
<details>
<summary>Changes</summary>
Reverts llvm/llvm-project#<!-- -->197728
unblock bots:
https://lab.llvm.org/buildbot/#/builders/226
https://lab.llvm.org/buildbot/#/builders/203
---
Patch is 58.02 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/198048.diff
19 Files Affected:
- (removed) mlir/include/mlir/Analysis/DataFlow/IntegerDivisibilityAnalysis.h (-64)
- (modified) mlir/include/mlir/Dialect/Affine/IR/AffineOps.td (+3-9)
- (modified) mlir/include/mlir/Dialect/Arith/IR/Arith.h (-1)
- (modified) mlir/include/mlir/Dialect/Arith/IR/ArithOps.td (+8-20)
- (modified) mlir/include/mlir/Interfaces/CMakeLists.txt (-1)
- (removed) mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.h (-120)
- (removed) mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.td (-41)
- (modified) mlir/lib/Analysis/CMakeLists.txt (-3)
- (removed) mlir/lib/Analysis/DataFlow/IntegerDivisibilityAnalysis.cpp (-135)
- (modified) mlir/lib/Dialect/Affine/IR/CMakeLists.txt (-2)
- (removed) mlir/lib/Dialect/Affine/IR/InferIntDivisibilityOpInterfaceImpl.cpp (-312)
- (modified) mlir/lib/Dialect/Arith/IR/CMakeLists.txt (-3)
- (removed) mlir/lib/Dialect/Arith/IR/InferIntDivisibilityOpInterfaceImpl.cpp (-122)
- (modified) mlir/lib/Interfaces/CMakeLists.txt (-2)
- (removed) mlir/lib/Interfaces/InferIntDivisibilityOpInterface.cpp (-11)
- (removed) mlir/test/Analysis/DataFlow/integer-divisibility.mlir (-152)
- (modified) mlir/test/lib/Analysis/CMakeLists.txt (-2)
- (removed) mlir/test/lib/Analysis/DataFlow/TestIntegerDivisibilityAnalysis.cpp (-93)
- (modified) mlir/tools/mlir-opt/mlir-opt.cpp (-2)
``````````diff
diff --git a/mlir/include/mlir/Analysis/DataFlow/IntegerDivisibilityAnalysis.h b/mlir/include/mlir/Analysis/DataFlow/IntegerDivisibilityAnalysis.h
deleted file mode 100644
index 3a877647490a3..0000000000000
--- a/mlir/include/mlir/Analysis/DataFlow/IntegerDivisibilityAnalysis.h
+++ /dev/null
@@ -1,64 +0,0 @@
-//===- IntegerDivisibilityAnalysis.h - Integer divisibility -----*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares the dataflow analysis class for integer divisibility
-// inference. Operations participate in the analysis by implementing
-// `InferIntDivisibilityOpInterface`.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_ANALYSIS_DATAFLOW_INTEGERDIVISIBILITYANALYSIS_H
-#define MLIR_ANALYSIS_DATAFLOW_INTEGERDIVISIBILITYANALYSIS_H
-
-#include "mlir/Analysis/DataFlow/SparseAnalysis.h"
-#include "mlir/Interfaces/InferIntDivisibilityOpInterface.h"
-
-namespace mlir::dataflow {
-
-/// This lattice element represents the integer divisibility of an SSA value.
-class IntegerDivisibilityLattice : public Lattice<IntegerDivisibility> {
-public:
- using Lattice::Lattice;
-};
-
-/// Integer divisibility analysis determines, for each integer-typed SSA
-/// value, a divisor that the value is guaranteed to be a multiple of. It
-/// uses operations that implement `InferIntDivisibilityOpInterface` and
-/// also sets the divisibility of induction variables of loops with known
-/// lower bounds and steps.
-///
-/// This analysis depends on DeadCodeAnalysis, and will be a silent no-op
-/// if DeadCodeAnalysis is not loaded in the same solver context.
-class IntegerDivisibilityAnalysis
- : public SparseForwardDataFlowAnalysis<IntegerDivisibilityLattice> {
-public:
- using SparseForwardDataFlowAnalysis::SparseForwardDataFlowAnalysis;
-
- /// At an entry point, set the lattice to the most pessimistic state,
- /// indicating that no further reasoning can be done.
- void setToEntryState(IntegerDivisibilityLattice *lattice) override;
-
- /// Visit an operation, invoking the transfer function.
- LogicalResult
- visitOperation(Operation *op,
- ArrayRef<const IntegerDivisibilityLattice *> operands,
- ArrayRef<IntegerDivisibilityLattice *> results) override;
-
- /// Visit block arguments or operation results of an operation with region
- /// control-flow for which values are not defined by region control-flow. This
- /// function tries to infer the divisibility of loop induction variables based
- /// on known loop bounds and steps.
- void visitNonControlFlowArguments(
- Operation *op, const RegionSuccessor &successor,
- ValueRange successorInputs,
- ArrayRef<IntegerDivisibilityLattice *> argLattices) override;
-};
-
-} // namespace mlir::dataflow
-
-#endif // MLIR_ANALYSIS_DATAFLOW_INTEGERDIVISIBILITYANALYSIS_H
diff --git a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
index 3d7cbcc375d2a..b2a4cf7f488bd 100644
--- a/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
+++ b/mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
@@ -16,7 +16,6 @@
include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td"
-include "mlir/Interfaces/InferIntDivisibilityOpInterface.td"
include "mlir/Interfaces/InferIntRangeInterface.td"
include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/LoopLikeInterface.td"
@@ -44,9 +43,7 @@ def ImplicitAffineTerminator
: SingleBlockImplicitTerminator<"AffineYieldOp">;
def AffineApplyOp : Affine_Op<"apply",
- [Pure,
- DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>,
- DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRanges"]>]> {
+ [Pure, DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRanges"]>]> {
let summary = "affine apply operation";
let description = [{
The `affine.apply` operation applies an [affine mapping](#affine-maps)
@@ -573,8 +570,7 @@ class AffineMinMaxOpBase<string mnemonic, list<Trait> traits = []> :
let hasVerifier = 1;
}
-def AffineMinOp : AffineMinMaxOpBase<"min",
- [Pure, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def AffineMinOp : AffineMinMaxOpBase<"min", [Pure]> {
let summary = "min operation";
let description = [{
Syntax:
@@ -598,8 +594,7 @@ def AffineMinOp : AffineMinMaxOpBase<"min",
}];
}
-def AffineMaxOp : AffineMinMaxOpBase<"max",
- [Pure, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def AffineMaxOp : AffineMinMaxOpBase<"max", [Pure]> {
let summary = "max operation";
let description = [{
The `affine.max` operation computes the maximum value result from a multi-result
@@ -1076,7 +1071,6 @@ def AffineVectorStoreOp : AffineStoreOpBase<"vector_store"> {
def AffineDelinearizeIndexOp : Affine_Op<"delinearize_index",
[Pure, Elementwise,
- DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>,
// Infer linear_index type from the first result type during parsing.
TypesMatchWith<"linear_index type must match result types",
"multi_index", "linear_index", "$_self[0]">
diff --git a/mlir/include/mlir/Dialect/Arith/IR/Arith.h b/mlir/include/mlir/Dialect/Arith/IR/Arith.h
index bf6eb18df2e8a..0fc3db8e993d8 100644
--- a/mlir/include/mlir/Dialect/Arith/IR/Arith.h
+++ b/mlir/include/mlir/Dialect/Arith/IR/Arith.h
@@ -15,7 +15,6 @@
#include "mlir/IR/OpImplementation.h"
#include "mlir/Interfaces/CastInterfaces.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h"
-#include "mlir/Interfaces/InferIntDivisibilityOpInterface.h"
#include "mlir/Interfaces/InferIntRangeInterface.h"
#include "mlir/Interfaces/InferTypeOpInterface.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
diff --git a/mlir/include/mlir/Dialect/Arith/IR/ArithOps.td b/mlir/include/mlir/Dialect/Arith/IR/ArithOps.td
index 1f8b07aed3f0d..fa85b840e2707 100644
--- a/mlir/include/mlir/Dialect/Arith/IR/ArithOps.td
+++ b/mlir/include/mlir/Dialect/Arith/IR/ArithOps.td
@@ -13,7 +13,6 @@ include "mlir/Dialect/Arith/IR/ArithBase.td"
include "mlir/Dialect/Arith/IR/ArithOpsInterfaces.td"
include "mlir/Interfaces/CastInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td"
-include "mlir/Interfaces/InferIntDivisibilityOpInterface.td"
include "mlir/Interfaces/InferIntRangeInterface.td"
include "mlir/Interfaces/InferTypeOpInterface.td"
include "mlir/Interfaces/SideEffectInterfaces.td"
@@ -224,7 +223,6 @@ def Arith_ConstantOp : Op<Arith_Dialect, "constant",
[ConstantLike, Pure,
DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
AllTypesMatch<["value", "result"]>,
- DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>,
DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRanges"]>]> {
let summary = "integer or floating point constant";
let description = [{
@@ -272,8 +270,7 @@ def Arith_ConstantOp : Op<Arith_Dialect, "constant",
// AddIOp
//===----------------------------------------------------------------------===//
-def Arith_AddIOp : Arith_IntBinaryOpWithOverflowFlags<"addi",
- [Commutative, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def Arith_AddIOp : Arith_IntBinaryOpWithOverflowFlags<"addi", [Commutative]> {
let summary = "integer addition operation";
let description = [{
Performs N-bit addition on the operands. The operands are interpreted as
@@ -419,8 +416,7 @@ def Arith_SubUIExtendedOp : Arith_Op<"subui_extended", [Pure,
// SubIOp
//===----------------------------------------------------------------------===//
-def Arith_SubIOp : Arith_IntBinaryOpWithOverflowFlags<"subi",
- [DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def Arith_SubIOp : Arith_IntBinaryOpWithOverflowFlags<"subi"> {
let summary = [{
Integer subtraction operation.
}];
@@ -465,9 +461,7 @@ def Arith_SubIOp : Arith_IntBinaryOpWithOverflowFlags<"subi",
//===----------------------------------------------------------------------===//
def Arith_MulIOp : Arith_IntBinaryOpWithOverflowFlags<"muli",
- [Commutative,
- DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>,
- DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]
+ [Commutative, DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]
> {
let summary = [{
Integer multiplication operation.
@@ -599,8 +593,7 @@ def Arith_MulUIExtendedOp : Arith_Op<"mului_extended", [Pure, Commutative,
//===----------------------------------------------------------------------===//
def Arith_DivUIOp : Arith_IntBinaryOpWithExactFlag<"divui",
- [ConditionallySpeculatable,
- DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+ [ConditionallySpeculatable]> {
let summary = "unsigned integer division operation";
let description = [{
Unsigned integer division. Rounds towards zero. Treats the leading bit as
@@ -1198,8 +1191,7 @@ def Arith_MaxNumFOp : Arith_FloatBinaryOp<"maxnumf", [Commutative]> {
// MaxSIOp
//===----------------------------------------------------------------------===//
-def Arith_MaxSIOp : Arith_TotalIntBinaryOp<"maxsi",
- [Commutative, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def Arith_MaxSIOp : Arith_TotalIntBinaryOp<"maxsi", [Commutative]> {
let summary = "signed integer maximum operation";
let hasFolder = 1;
}
@@ -1208,8 +1200,7 @@ def Arith_MaxSIOp : Arith_TotalIntBinaryOp<"maxsi",
// MaxUIOp
//===----------------------------------------------------------------------===//
-def Arith_MaxUIOp : Arith_TotalIntBinaryOp<"maxui",
- [Commutative, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def Arith_MaxUIOp : Arith_TotalIntBinaryOp<"maxui", [Commutative]> {
let summary = "unsigned integer maximum operation";
let hasFolder = 1;
}
@@ -1259,8 +1250,7 @@ def Arith_MinNumFOp : Arith_FloatBinaryOp<"minnumf", [Commutative]> {
// MinSIOp
//===----------------------------------------------------------------------===//
-def Arith_MinSIOp : Arith_TotalIntBinaryOp<"minsi",
- [Commutative, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def Arith_MinSIOp : Arith_TotalIntBinaryOp<"minsi", [Commutative]> {
let summary = "signed integer minimum operation";
let hasFolder = 1;
}
@@ -1269,8 +1259,7 @@ def Arith_MinSIOp : Arith_TotalIntBinaryOp<"minsi",
// MinUIOp
//===----------------------------------------------------------------------===//
-def Arith_MinUIOp : Arith_TotalIntBinaryOp<"minui",
- [Commutative, DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>]> {
+def Arith_MinUIOp : Arith_TotalIntBinaryOp<"minui", [Commutative]> {
let summary = "unsigned integer minimum operation";
let hasFolder = 1;
}
@@ -2015,7 +2004,6 @@ class BooleanConditionOrMatchingShape<string condition, string result> :
def SelectOp : Arith_Op<"select", [Pure,
AllTypesMatch<["true_value", "false_value", "result"]>,
BooleanConditionOrMatchingShape<"condition", "result">,
- DeclareOpInterfaceMethods<InferIntDivisibilityOpInterface>,
DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRangesFromOptional"]>,
DeclareOpInterfaceMethods<SelectLikeOpInterface>]> {
let summary = "select operation";
diff --git a/mlir/include/mlir/Interfaces/CMakeLists.txt b/mlir/include/mlir/Interfaces/CMakeLists.txt
index 6461c68423c73..3cbc9df05f3d7 100644
--- a/mlir/include/mlir/Interfaces/CMakeLists.txt
+++ b/mlir/include/mlir/Interfaces/CMakeLists.txt
@@ -6,7 +6,6 @@ add_mlir_interface(DerivedAttributeOpInterface)
add_mlir_interface(DestinationStyleOpInterface)
add_mlir_interface(FunctionInterfaces)
add_mlir_interface(IndexingMapOpInterface)
-add_mlir_interface(InferIntDivisibilityOpInterface)
add_mlir_interface(InferIntRangeInterface)
add_mlir_interface(InferStridedMetadataInterface)
add_mlir_interface(InferTypeOpInterface)
diff --git a/mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.h b/mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.h
deleted file mode 100644
index 374acee05cb10..0000000000000
--- a/mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.h
+++ /dev/null
@@ -1,120 +0,0 @@
-//===- InferIntDivisibilityOpInterface.h - Integer Divisibility -*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains definitions of the integer divisibility inference
-// interface defined in `InferIntDivisibilityOpInterface.td`.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_INTERFACES_INFERINTDIVISIBILITYOPINTERFACE_H
-#define MLIR_INTERFACES_INFERINTDIVISIBILITYOPINTERFACE_H
-
-#include "mlir/IR/OpDefinition.h"
-#include <numeric>
-#include <optional>
-
-namespace mlir {
-
-/// Statically known divisibility information for an integer SSA value.
-/// Tracks separate divisors for the unsigned and signed interpretations of
-/// the value so that subsequent analyses can use whichever is more precise.
-class ConstantIntDivisibility {
-public:
- ConstantIntDivisibility() = default;
- ConstantIntDivisibility(uint64_t udiv, uint64_t sdiv)
- : udivVal(udiv), sdivVal(sdiv) {}
-
- bool operator==(const ConstantIntDivisibility &other) const {
- return udivVal == other.udivVal && sdivVal == other.sdivVal;
- }
-
- uint64_t udiv() const { return this->udivVal; }
- uint64_t sdiv() const { return this->sdivVal; }
-
- // Returns the union (computed separately for signed and unsigned bounds)
- // for this divisibility and `other`.
- ConstantIntDivisibility getUnion(const ConstantIntDivisibility &other) const {
- return ConstantIntDivisibility(
- /*udiv=*/std::gcd(udiv(), other.udiv()),
- /*sdiv=*/std::gcd(sdiv(), other.sdiv()));
- }
-
-private:
- uint64_t udivVal;
- uint64_t sdivVal;
-
- friend raw_ostream &operator<<(raw_ostream &os,
- const ConstantIntDivisibility &div);
-};
-
-inline raw_ostream &operator<<(raw_ostream &os,
- const ConstantIntDivisibility &div) {
- os << "ConstantIntDivisibility(udiv = " << div.udivVal
- << ", sdiv = " << div.sdivVal << ")";
- return os;
-}
-
-/// This lattice value represents the integer divisibility of an SSA value.
-class IntegerDivisibility {
-public:
- IntegerDivisibility(ConstantIntDivisibility value)
- : value(std::move(value)) {}
- explicit IntegerDivisibility(
- std::optional<ConstantIntDivisibility> value = std::nullopt)
- : value(std::move(value)) {}
- // Gets the minimum divisibility of 1 that is used to indicate that the value
- // cannot be analyzed further.
- static IntegerDivisibility getMinDivisibility() {
- return IntegerDivisibility(ConstantIntDivisibility(1, 1));
- }
-
- bool isUninitialized() const { return !value.has_value(); }
- const ConstantIntDivisibility &getValue() const {
- assert(!isUninitialized());
- return *value;
- }
-
- bool operator==(const IntegerDivisibility &rhs) const {
- return value == rhs.value;
- }
-
- static IntegerDivisibility join(const IntegerDivisibility &lhs,
- const IntegerDivisibility &rhs) {
- if (lhs.isUninitialized()) {
- return rhs;
- }
- if (rhs.isUninitialized()) {
- return lhs;
- }
- return IntegerDivisibility(lhs.getValue().getUnion(rhs.getValue()));
- }
-
- void print(raw_ostream &os) const { os << value; }
-
-private:
- std::optional<ConstantIntDivisibility> value;
-};
-
-inline raw_ostream &operator<<(raw_ostream &os,
- const IntegerDivisibility &div) {
- div.print(os);
- return os;
-}
-
-/// The type of the `setResultDivs` callback provided to ops implementing
-/// InferIntDivisibilityOpInterface. It should be called once for each integer
-/// result value and be passed the ConstantIntDivisibility corresponding to
-/// that value.
-using SetIntDivisibilityFn =
- llvm::function_ref<void(Value, const ConstantIntDivisibility &)>;
-
-} // end namespace mlir
-
-#include "mlir/Interfaces/InferIntDivisibilityOpInterface.h.inc"
-
-#endif // MLIR_INTERFACES_INFERINTDIVISIBILITYOPINTERFACE_H
diff --git a/mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.td b/mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.td
deleted file mode 100644
index c665475e0fd7f..0000000000000
--- a/mlir/include/mlir/Interfaces/InferIntDivisibilityOpInterface.td
+++ /dev/null
@@ -1,41 +0,0 @@
-//===- InferIntDivisibilityOpInterface.td - Integer Divisibility -*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Defines the interface for divisibility analysis on scalar integers.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_INTERFACES_INFERINTDIVISIBILITYOPINTERFACE
-#define MLIR_INTERFACES_INFERINTDIVISIBILITYOPINTERFACE
-
-include "mlir/IR/OpBase.td"
-
-def InferIntDivisibilityOpInterface :
- OpInterface<"InferIntDivisibilityOpInterface"> {
- let description = [{
- Allows operations to participate in integer divisibility analysis.
- }];
- let cppNamespace = "::mlir";
-
- let methods = [
- InterfaceMethod<
- /*desc=*/[{
- Infer the divisibility of the results of this op given the
- divisibility of its arguments. For each result value, the method
- should call `setResultDivs` with that `Value` as an argument.
- }],
- /*retTy=*/"void",
- /*methodName=*/"inferResultDivisibility",
- /*args=*/(ins
- "::llvm::ArrayRef<::mlir::IntegerDivisibility>":$argDivs,
- "::mlir::SetIntDivisibilityFn":$setResultDivs)
- >
- ];
-}
-
-#endif // MLIR_INTERFACES_INFERINTDIVISIBILITYOPINTERFACE
diff --git a/mlir/lib/Analysis/CMakeLists.txt b/mlir/lib/Analysis/CMakeLists.txt
index 596ffaff428b5..db10ebcf2c311 100644
--- a/mlir/lib/Analysis/CMakeLists.txt
+++ b/mlir/lib/Analysis/CMakeLists.txt
@@ -13,7 +13,6 @@ set(LLVM_OPTIONAL_SOURCES
DataFlow/ConstantPropagationAnalysis.cpp
DataFlow/DeadCodeAnalysis.cpp
DataFlow/DenseAnalysis.cpp
- DataFlow/IntegerDivisibilityAnalysis.cpp
DataFlow/IntegerRangeAnalysis.cpp
DataFlow/LivenessAnalysis.cpp
DataFlow/SparseAnalysis.cpp
@@ -38,7 +37,6 @@ add_mlir_library(MLIRAnalysis
DataFlow/ConstantPropagationAnalysis.cpp
DataFlow/DeadCodeAnalysis.cpp
DataFlow/DenseAnalysis.cpp
- DataFlow/IntegerDivisibilityAnalysis.cpp
DataFlow/IntegerRangeAnalysis.cpp
DataFlow/LivenessAnalysis.cpp
DataFlow/SparseAnalysis.cpp
@@ -55,7 +53,6 @@ add_mlir_library(MLIRAnalysis
MLIRControlFlowInterfaces
MLIRDataLayoutInterfaces
MLIRFunctionInterfaces
- MLIRInferIntDivisibilityOpInterface
MLIRInferIntRangeInterface
MLIRInferStridedMetadataInterface
MLIRInferTypeOpInterface
diff --git a/mlir/lib/Analysis/DataFlow/IntegerDivisibilityAnalysis.cpp b/mlir/lib/Analysis/DataFlow/IntegerDivisibilityAnalysis.cpp
deleted file mode 100644
index ba10a8b5a0060..0000000000000
--- a/mlir/lib/Analysis/DataFlow/IntegerDivisibilityAnalysis.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//===- IntegerDivisibilityAnalysis.cpp - Integer divisibility ---*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the dataflow analysis class for ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/198048
More information about the Mlir-commits
mailing list