Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/DeviceMappingAttributes.cpp.inc

@@ -0,0 +1,8 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* AttrDef Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/DeviceMappingAttributes.h.inc

@@ -0,0 +1,19 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* AttrDef Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_ATTRDEF_CLASSES
+#undef GET_ATTRDEF_CLASSES
+
+
+namespace mlir {
+class AsmParser;
+class AsmPrinter;
+} // namespace mlir
+
+#endif  // GET_ATTRDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/DeviceMappingInterface.h

@@ -0,0 +1,22 @@
+//===- DeviceMappingInterface.h - -------------------------------*- 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 the definitions of the device mapping interface defined in
+// `DeviceMappingInterface.td`.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DEVICEMAPPINGINTERFACE_H
+#define MLIR_DEVICEMAPPINGINTERFACE_H
+
+#include "mlir/IR/OpDefinition.h"
+
+/// Include the generated interface declarations.
+#include "mlir/Dialect/SCF/IR/DeviceMappingAttrInterface.h.inc"
+
+#endif // MLIR_DEVICEMAPPINGINTERFACE_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/SCF.h

@@ -0,0 +1,112 @@
+//===- SCFOps.h - Structured Control Flow -----------------------*- 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 structured control flow operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SCF_SCF_H
+#define MLIR_DIALECT_SCF_SCF_H
+
+#include "mlir/Dialect/Arith/Utils/Utils.h"
+#include "mlir/Dialect/SCF/IR/DeviceMappingInterface.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/RegionKindInterface.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/DestinationStyleOpInterface.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/LoopLikeInterface.h"
+#include "mlir/Interfaces/ParallelCombiningOpInterface.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+#include "mlir/Interfaces/ViewLikeInterface.h"
+
+namespace mlir {
+namespace scf {
+void buildTerminatedBody(OpBuilder &builder, Location loc);
+} // namespace scf
+} // namespace mlir
+
+#include "mlir/Dialect/SCF/IR/SCFOpsDialect.h.inc"
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/SCF/IR/SCFOps.h.inc"
+
+namespace mlir {
+namespace scf {
+
+// Insert `loop.yield` at the end of the only region's only block if it
+// does not have a terminator already.  If a new `loop.yield` is inserted,
+// the location is specified by `loc`. If the region is empty, insert a new
+// block first.
+void ensureLoopTerminator(Region &region, Builder &builder, Location loc);
+
+/// Returns the loop parent of an induction variable. If the provided value is
+/// not an induction variable, then return nullptr.
+ForOp getForInductionVarOwner(Value val);
+
+/// Returns the parallel loop parent of an induction variable. If the provided
+/// value is not an induction variable, then return nullptr.
+ParallelOp getParallelForInductionVarOwner(Value val);
+
+/// Returns the ForallOp parent of an thread index variable.
+/// If the provided value is not a thread index variable, then return nullptr.
+ForallOp getForallOpThreadIndexOwner(Value val);
+
+/// Return true if ops a and b (or their ancestors) are in mutually exclusive
+/// regions/blocks of an IfOp.
+// TODO: Consider moving this functionality to RegionBranchOpInterface.
+bool insideMutuallyExclusiveBranches(Operation *a, Operation *b);
+
+/// Promotes the loop body of a scf::ForallOp to its containing block.
+void promote(RewriterBase &rewriter, scf::ForallOp forallOp);
+
+/// An owning vector of values, handy to return from functions.
+using ValueVector = SmallVector<Value>;
+using LoopVector = SmallVector<scf::ForOp>;
+struct LoopNest {
+  LoopVector loops;
+  ValueVector results;
+};
+
+/// Creates a perfect nest of "for" loops, i.e. all loops but the innermost
+/// contain only another loop and a terminator. The lower, upper bounds and
+/// steps are provided as `lbs`, `ubs` and `steps`, which are expected to be of
+/// the same size. `iterArgs` points to the initial values of the loop iteration
+/// arguments, which will be forwarded through the nest to the innermost loop.
+/// The body of the loop is populated using `bodyBuilder`, which accepts an
+/// ordered list of induction variables of all loops, followed by a list of
+/// iteration arguments of the innermost loop, in the same order as provided to
+/// `iterArgs`. This function is expected to return as many values as
+/// `iterArgs`, of the same type and in the same order, that will be treated as
+/// yielded from the loop body and forwarded back through the loop nest. If the
+/// function is not provided, the loop nest is not expected to have iteration
+/// arguments, the body of the innermost loop will be left empty, containing
+/// only the zero-operand terminator. Returns the LoopNest containing the list
+/// of perfectly nest scf::ForOp build during the call.
+/// If bound arrays are empty, the body builder will be called
+/// once to construct the IR outside of the loop with an empty list of induction
+/// variables.
+LoopNest buildLoopNest(
+    OpBuilder &builder, Location loc, ValueRange lbs, ValueRange ubs,
+    ValueRange steps, ValueRange iterArgs,
+    function_ref<ValueVector(OpBuilder &, Location, ValueRange, ValueRange)>
+        bodyBuilder = nullptr);
+
+/// A convenience version for building loop nests without iteration arguments
+/// (like for reductions). Does not take the initial value of reductions or
+/// expect the body building functions to return their current value.
+/// The built nested scf::For are captured in `capturedLoops` when non-null.
+LoopNest buildLoopNest(OpBuilder &builder, Location loc, ValueRange lbs,
+                       ValueRange ubs, ValueRange steps,
+                       function_ref<void(OpBuilder &, Location, ValueRange)>
+                           bodyBuilder = nullptr);
+
+} // namespace scf
+} // namespace mlir
+#endif // MLIR_DIALECT_SCF_SCF_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/SCFOps.h.inc

@@ -0,0 +1,1885 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Op Declarations                                                            *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SCFOps.td                                                            *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#if defined(GET_OP_CLASSES) || defined(GET_OP_FWD_DEFINES)
+#undef GET_OP_FWD_DEFINES
+namespace mlir {
+namespace scf {
+class ConditionOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class ExecuteRegionOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class ForOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class ForallOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class IfOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class InParallelOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class IndexSwitchOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class ParallelOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class ReduceOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class ReduceReturnOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class WhileOp;
+} // namespace scf
+} // namespace mlir
+namespace mlir {
+namespace scf {
+class YieldOp;
+} // namespace scf
+} // namespace mlir
+#endif
+
+#ifdef GET_OP_CLASSES
+#undef GET_OP_CLASSES
+
+
+//===----------------------------------------------------------------------===//
+// Local Utility Method Definitions
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ConditionOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ConditionOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  ConditionOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ConditionOpGenericAdaptorBase(ConditionOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+};
+} // namespace detail
+template <typename RangeT>
+class ConditionOpGenericAdaptor : public detail::ConditionOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ConditionOpGenericAdaptorBase;
+public:
+  ConditionOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ConditionOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ConditionOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = ConditionOp, typename = std::enable_if_t<std::is_same_v<LateInst, ConditionOp>>>
+  ConditionOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  ValueT getCondition() {
+    return (*getODSOperands(0).begin());
+  }
+
+  RangeT getArgs() {
+    return getODSOperands(1);
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ConditionOpAdaptor : public ConditionOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ConditionOpGenericAdaptor::ConditionOpGenericAdaptor;
+  ConditionOpAdaptor(ConditionOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ConditionOp : public ::mlir::Op<ConditionOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::HasParent<WhileOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ConditionOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ConditionOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.condition");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::TypedValue<::mlir::IntegerType> getCondition();
+  ::mlir::Operation::operand_range getArgs();
+  ::mlir::OpOperand &getConditionMutable();
+  ::mlir::MutableOperandRange getArgsMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value condition, ::mlir::ValueRange args);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::ValueRange args);
+  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::MutableOperandRange getMutableSuccessorOperands(::mlir::RegionBranchPoint point);
+  void getSuccessorRegions(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &_odsPrinter);
+  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
+public:
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ConditionOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ExecuteRegionOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ExecuteRegionOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  ExecuteRegionOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ExecuteRegionOpGenericAdaptorBase(ExecuteRegionOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getRegion();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class ExecuteRegionOpGenericAdaptor : public detail::ExecuteRegionOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ExecuteRegionOpGenericAdaptorBase;
+public:
+  ExecuteRegionOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ExecuteRegionOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ExecuteRegionOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = ExecuteRegionOp, typename = std::enable_if_t<std::is_same_v<LateInst, ExecuteRegionOp>>>
+  ExecuteRegionOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ExecuteRegionOpAdaptor : public ExecuteRegionOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ExecuteRegionOpGenericAdaptor::ExecuteRegionOpGenericAdaptor;
+  ExecuteRegionOpAdaptor(ExecuteRegionOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ExecuteRegionOp : public ::mlir::Op<ExecuteRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchOpInterface::Trait> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ExecuteRegionOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ExecuteRegionOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.execute_region");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Region &getRegion();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultType0);
+  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+public:
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ExecuteRegionOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ForOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ForOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  ForOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ForOpGenericAdaptorBase(ForOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getRegion();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class ForOpGenericAdaptor : public detail::ForOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ForOpGenericAdaptorBase;
+public:
+  ForOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ForOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ForOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = ForOp, typename = std::enable_if_t<std::is_same_v<LateInst, ForOp>>>
+  ForOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  ValueT getLowerBound() {
+    return (*getODSOperands(0).begin());
+  }
+
+  ValueT getUpperBound() {
+    return (*getODSOperands(1).begin());
+  }
+
+  ValueT getStep() {
+    return (*getODSOperands(2).begin());
+  }
+
+  RangeT getInitArgs() {
+    return getODSOperands(3);
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ForOpAdaptor : public ForOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ForOpGenericAdaptor::ForOpGenericAdaptor;
+  ForOpAdaptor(ForOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ForOp : public ::mlir::Op<ForOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<3>::Impl, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<scf::YieldOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::AutomaticAllocationScope, ::mlir::LoopLikeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::RegionBranchOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ForOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ForOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.for");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Value getLowerBound();
+  ::mlir::Value getUpperBound();
+  ::mlir::Value getStep();
+  ::mlir::Operation::operand_range getInitArgs();
+  ::mlir::OpOperand &getLowerBoundMutable();
+  ::mlir::OpOperand &getUpperBoundMutable();
+  ::mlir::OpOperand &getStepMutable();
+  ::mlir::MutableOperandRange getInitArgsMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Operation::result_range getResults();
+  ::mlir::Region &getRegion();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value lowerBound, Value upperBound, Value step, ValueRange iterArgs = std::nullopt, function_ref<void(OpBuilder &, Location, Value, ValueRange)> odsArg4 = nullptr);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  ::mlir::LogicalResult verifyRegions();
+  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
+  ::llvm::SmallVector<::mlir::Region *> getLoopRegions();
+  ::mlir::LogicalResult promoteIfSingleIteration(::mlir::RewriterBase &rewriter);
+  ::std::optional<::mlir::Value> getSingleInductionVar();
+  ::std::optional<::mlir::OpFoldResult> getSingleLowerBound();
+  ::std::optional<::mlir::OpFoldResult> getSingleStep();
+  ::std::optional<::mlir::OpFoldResult> getSingleUpperBound();
+  ::mlir::OperandRange getInits();
+  ::mlir::FailureOr<::mlir::LoopLikeOpInterface> replaceWithAdditionalYields(::mlir::RewriterBase &rewriter, ::mlir::ValueRange newInitOperands, bool replaceInitOperandUsesInLoop, const ::mlir::NewYieldValuesFn &newYieldValuesFn);
+  ::mlir::OperandRange getEntrySuccessorOperands(::mlir::RegionBranchPoint point);
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+public:
+  using BodyBuilderFn =
+      function_ref<void(OpBuilder &, Location, Value, ValueRange)>;
+
+  Value getInductionVar() { return getBody()->getArgument(0); }
+  Block::BlockArgListType getRegionIterArgs() {
+    return getBody()->getArguments().drop_front(getNumInductionVars());
+  }
+  /// Return the `index`-th region iteration argument.
+  BlockArgument getRegionIterArg(unsigned index) {
+    assert(index < getNumRegionIterArgs() &&
+      "expected an index less than the number of region iter args");
+    return getBody()->getArguments().drop_front(getNumInductionVars())[index];
+  }
+
+  void setLowerBound(Value bound) { getOperation()->setOperand(0, bound); }
+  void setUpperBound(Value bound) { getOperation()->setOperand(1, bound); }
+  void setStep(Value step) { getOperation()->setOperand(2, step); }
+
+  /// Number of induction variables, always 1 for scf::ForOp.
+  unsigned getNumInductionVars() { return 1; }
+  /// Number of region arguments for loop-carried values
+  unsigned getNumRegionIterArgs() {
+    return getBody()->getNumArguments() - getNumInductionVars();
+  }
+  /// Number of operands controlling the loop: lb, ub, step
+  unsigned getNumControlOperands() { return 3; }
+
+  /// Get the region iter arg that corresponds to an OpOperand.
+  /// This helper prevents internal op implementation detail leakage to
+  /// clients by hiding the operand / block argument mapping.
+  BlockArgument getRegionIterArgForOpOperand(OpOperand &opOperand) {
+    assert(opOperand.getOperandNumber() >= getNumControlOperands() &&
+           "expected an iter args operand");
+    assert(opOperand.getOwner() == getOperation() &&
+           "opOperand does not belong to this scf::ForOp operation");
+    return getRegionIterArgs()[
+      opOperand.getOperandNumber() - getNumControlOperands()];
+  }
+  /// Get the OpOperand& that corresponds to a region iter arg.
+  /// This helper prevents internal op implementation detail leakage to
+  /// clients by hiding the operand / block argument mapping.
+  OpOperand &getOpOperandForRegionIterArg(BlockArgument bbArg) {
+    assert(bbArg.getArgNumber() >= getNumInductionVars() &&
+           "expected a bbArg that is not an induction variable");
+    assert(bbArg.getOwner()->getParentOp() == getOperation() &&
+           "bbArg does not belong to the scf::ForOp body");
+    return getOperation()->getOpOperand(
+      getNumControlOperands() + bbArg.getArgNumber() - getNumInductionVars());
+  }
+  /// Get the OpResult that corresponds to an OpOperand.
+  /// Assert that opOperand is an iterArg.
+  /// This helper prevents internal op implementation detail leakage to
+  /// clients by hiding the operand / block argument mapping.
+  OpResult getResultForOpOperand(OpOperand &opOperand) {
+    assert(opOperand.getOperandNumber() >= getNumControlOperands() &&
+           "expected an iter args operand");
+    assert(opOperand.getOwner() == getOperation() &&
+           "opOperand does not belong to this scf::ForOp operation");
+    return getOperation()->getResult(
+      opOperand.getOperandNumber() - getNumControlOperands());
+  }
+  /// Get the OpOperand& that corresponds to an OpResultOpOperand.
+  /// This helper prevents internal op implementation detail leakage to
+  /// clients by hiding the operand / block argument mapping.
+  OpOperand &getOpOperandForResult(OpResult opResult) {
+    assert(opResult.getDefiningOp() == getOperation() &&
+           "opResult does not belong to the scf::ForOp operation");
+    return getOperation()->getOpOperand(
+      getNumControlOperands() + opResult.getResultNumber());
+  }
+
+  /// Returns the step as an `APInt` if it is constant.
+  std::optional<APInt> getConstantStep();
+
+  /// Interface method for ConditionallySpeculatable.
+  Speculation::Speculatability getSpeculatability();
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ForOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ForallOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ForallOpGenericAdaptorBase {
+public:
+  struct Properties {
+    using mappingTy = ::mlir::ArrayAttr;
+    mappingTy mapping;
+
+    auto getMapping() {
+      auto &propStorage = this->mapping;
+      return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage);
+    }
+    void setMapping(const ::mlir::ArrayAttr &propValue) {
+      this->mapping = propValue;
+    }
+    using staticLowerBoundTy = ::mlir::DenseI64ArrayAttr;
+    staticLowerBoundTy staticLowerBound;
+
+    auto getStaticLowerBound() {
+      auto &propStorage = this->staticLowerBound;
+      return ::llvm::cast<::mlir::DenseI64ArrayAttr>(propStorage);
+    }
+    void setStaticLowerBound(const ::mlir::DenseI64ArrayAttr &propValue) {
+      this->staticLowerBound = propValue;
+    }
+    using staticStepTy = ::mlir::DenseI64ArrayAttr;
+    staticStepTy staticStep;
+
+    auto getStaticStep() {
+      auto &propStorage = this->staticStep;
+      return ::llvm::cast<::mlir::DenseI64ArrayAttr>(propStorage);
+    }
+    void setStaticStep(const ::mlir::DenseI64ArrayAttr &propValue) {
+      this->staticStep = propValue;
+    }
+    using staticUpperBoundTy = ::mlir::DenseI64ArrayAttr;
+    staticUpperBoundTy staticUpperBound;
+
+    auto getStaticUpperBound() {
+      auto &propStorage = this->staticUpperBound;
+      return ::llvm::cast<::mlir::DenseI64ArrayAttr>(propStorage);
+    }
+    void setStaticUpperBound(const ::mlir::DenseI64ArrayAttr &propValue) {
+      this->staticUpperBound = propValue;
+    }
+    using operandSegmentSizesTy = std::array<int32_t, 4>;
+    operandSegmentSizesTy operandSegmentSizes;
+    ::llvm::ArrayRef<int32_t> getOperandSegmentSizes() {
+      auto &propStorage = this->operandSegmentSizes;
+      return propStorage;
+    }
+    void setOperandSegmentSizes(const ::llvm::ArrayRef<int32_t> &propValue) {
+      auto &propStorage = this->operandSegmentSizes;
+      ::llvm::copy(propValue, propStorage.begin());
+    }
+    bool operator==(const Properties &rhs) const {
+      return 
+        rhs.mapping == this->mapping &&
+        rhs.staticLowerBound == this->staticLowerBound &&
+        rhs.staticStep == this->staticStep &&
+        rhs.staticUpperBound == this->staticUpperBound &&
+        rhs.operandSegmentSizes == this->operandSegmentSizes &&
+        true;
+    }
+    bool operator!=(const Properties &rhs) const {
+      return !(*this == rhs);
+    }
+  };
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  Properties properties;
+  ::mlir::RegionRange odsRegions;
+public:
+  ForallOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ForallOpGenericAdaptorBase(ForallOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  const Properties &getProperties() {
+    return properties;
+  }
+
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::DenseI64ArrayAttr getStaticLowerBoundAttr();
+  ::llvm::ArrayRef<int64_t> getStaticLowerBound();
+  ::mlir::DenseI64ArrayAttr getStaticUpperBoundAttr();
+  ::llvm::ArrayRef<int64_t> getStaticUpperBound();
+  ::mlir::DenseI64ArrayAttr getStaticStepAttr();
+  ::llvm::ArrayRef<int64_t> getStaticStep();
+  ::mlir::ArrayAttr getMappingAttr();
+  ::std::optional< ::mlir::ArrayAttr > getMapping();
+  ::mlir::Region &getRegion();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class ForallOpGenericAdaptor : public detail::ForallOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ForallOpGenericAdaptorBase;
+public:
+  ForallOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ForallOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ForallOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
+
+  template <typename LateInst = ForallOp, typename = std::enable_if_t<std::is_same_v<LateInst, ForallOp>>>
+  ForallOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  RangeT getDynamicLowerBound() {
+    return getODSOperands(0);
+  }
+
+  RangeT getDynamicUpperBound() {
+    return getODSOperands(1);
+  }
+
+  RangeT getDynamicStep() {
+    return getODSOperands(2);
+  }
+
+  RangeT getOutputs() {
+    return getODSOperands(3);
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ForallOpAdaptor : public ForallOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ForallOpGenericAdaptor::ForallOpGenericAdaptor;
+  ForallOpAdaptor(ForallOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ForallOp : public ::mlir::Op<ForallOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<scf::InParallelOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::AutomaticAllocationScope, ::mlir::LoopLikeOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects, ::mlir::RegionBranchOpInterface::Trait, ::mlir::DestinationStyleOpInterface::Trait> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ForallOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ForallOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  using Properties = FoldAdaptor::Properties;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    static ::llvm::StringRef attrNames[] = {::llvm::StringRef("mapping"), ::llvm::StringRef("staticLowerBound"), ::llvm::StringRef("staticStep"), ::llvm::StringRef("staticUpperBound"), ::llvm::StringRef("operandSegmentSizes")};
+    return ::llvm::ArrayRef(attrNames);
+  }
+
+  ::mlir::StringAttr getMappingAttrName() {
+    return getAttributeNameForIndex(0);
+  }
+
+  static ::mlir::StringAttr getMappingAttrName(::mlir::OperationName name) {
+    return getAttributeNameForIndex(name, 0);
+  }
+
+  ::mlir::StringAttr getStaticLowerBoundAttrName() {
+    return getAttributeNameForIndex(1);
+  }
+
+  static ::mlir::StringAttr getStaticLowerBoundAttrName(::mlir::OperationName name) {
+    return getAttributeNameForIndex(name, 1);
+  }
+
+  ::mlir::StringAttr getStaticStepAttrName() {
+    return getAttributeNameForIndex(2);
+  }
+
+  static ::mlir::StringAttr getStaticStepAttrName(::mlir::OperationName name) {
+    return getAttributeNameForIndex(name, 2);
+  }
+
+  ::mlir::StringAttr getStaticUpperBoundAttrName() {
+    return getAttributeNameForIndex(3);
+  }
+
+  static ::mlir::StringAttr getStaticUpperBoundAttrName(::mlir::OperationName name) {
+    return getAttributeNameForIndex(name, 3);
+  }
+
+  ::mlir::StringAttr getOperandSegmentSizesAttrName() {
+   return (*this)->getName().getAttributeNames().back();
+  }
+
+  static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) {
+   return name.getAttributeNames().back();
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.forall");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Operation::operand_range getDynamicLowerBound();
+  ::mlir::Operation::operand_range getDynamicUpperBound();
+  ::mlir::Operation::operand_range getDynamicStep();
+  ::mlir::Operation::operand_range getOutputs();
+  ::mlir::MutableOperandRange getDynamicLowerBoundMutable();
+  ::mlir::MutableOperandRange getDynamicUpperBoundMutable();
+  ::mlir::MutableOperandRange getDynamicStepMutable();
+  ::mlir::MutableOperandRange getOutputsMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Operation::result_range getResults();
+  ::mlir::Region &getRegion();
+  static ::mlir::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
+  static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
+  static llvm::hash_code computePropertiesHash(const Properties &prop);
+  static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
+  static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
+  static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
+  static ::mlir::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
+  static ::mlir::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
+  void writeProperties(::mlir::DialectBytecodeWriter &writer);
+  ::mlir::DenseI64ArrayAttr getStaticLowerBoundAttr();
+  ::llvm::ArrayRef<int64_t> getStaticLowerBound();
+  ::mlir::DenseI64ArrayAttr getStaticUpperBoundAttr();
+  ::llvm::ArrayRef<int64_t> getStaticUpperBound();
+  ::mlir::DenseI64ArrayAttr getStaticStepAttr();
+  ::llvm::ArrayRef<int64_t> getStaticStep();
+  ::mlir::ArrayAttr getMappingAttr();
+  ::std::optional< ::mlir::ArrayAttr > getMapping();
+  void setStaticLowerBoundAttr(::mlir::DenseI64ArrayAttr attr);
+  void setStaticLowerBound(::llvm::ArrayRef<int64_t> attrValue);
+  void setStaticUpperBoundAttr(::mlir::DenseI64ArrayAttr attr);
+  void setStaticUpperBound(::llvm::ArrayRef<int64_t> attrValue);
+  void setStaticStepAttr(::mlir::DenseI64ArrayAttr attr);
+  void setStaticStep(::llvm::ArrayRef<int64_t> attrValue);
+  void setMappingAttr(::mlir::ArrayAttr attr);
+  ::mlir::Attribute removeMappingAttr();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ArrayRef<OpFoldResult> lbs, ArrayRef<OpFoldResult> ubs, ArrayRef<OpFoldResult> steps, ValueRange outputs, std::optional<ArrayAttr> mapping, function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilderFn = nullptr);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ArrayRef<OpFoldResult> ubs, ValueRange outputs, std::optional<ArrayAttr> mapping, function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilderFn = nullptr);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
+  ::llvm::SmallVector<::mlir::Region *> getLoopRegions();
+  ::mlir::LogicalResult promoteIfSingleIteration(::mlir::RewriterBase &rewriter);
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+private:
+  ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
+    return getAttributeNameForIndex((*this)->getName(), index);
+  }
+
+  static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
+    assert(index < 4 && "invalid attribute index");
+    assert(name.getStringRef() == getOperationName() && "invalid operation name");
+    return name.getAttributeNames()[index];
+  }
+
+public:
+  // Get lower bounds as OpFoldResult.
+  SmallVector<OpFoldResult> getMixedLowerBound() {
+    Builder b(getOperation()->getContext());
+    return getMixedValues(getStaticLowerBound(), getDynamicLowerBound(), b);
+  }
+
+  // Get upper bounds as OpFoldResult.
+  SmallVector<OpFoldResult> getMixedUpperBound() {
+    Builder b(getOperation()->getContext());
+    return getMixedValues(getStaticUpperBound(), getDynamicUpperBound(), b);
+  }
+
+  // Get steps as OpFoldResult.
+  SmallVector<OpFoldResult> getMixedStep() {
+    Builder b(getOperation()->getContext());
+    return getMixedValues(getStaticStep(), getDynamicStep(), b);
+  }
+
+  /// Get lower bounds as values.
+  SmallVector<Value> getLowerBound(OpBuilder &b) {
+    return getValueOrCreateConstantIndexOp(b, getLoc(), getMixedLowerBound());
+  }
+
+  /// Get upper bounds as values.
+  SmallVector<Value> getUpperBound(OpBuilder &b) {
+    return getValueOrCreateConstantIndexOp(b, getLoc(), getMixedUpperBound());
+  }
+
+  /// Get steps as values.
+  SmallVector<Value> getStep(OpBuilder &b) {
+    return getValueOrCreateConstantIndexOp(b, getLoc(), getMixedStep());
+  }
+
+  int64_t getRank() { return getStaticLowerBound().size(); }
+
+  /// Number of operands controlling the loop: lbs, ubs, steps
+  unsigned getNumControlOperands() { return 3 * getRank(); }
+
+  /// Number of dynamic operands controlling the loop: lbs, ubs, steps
+  unsigned getNumDynamicControlOperands() {
+    return getODSOperandIndexAndLength(3).first;
+  }
+
+  OpResult getTiedOpResult(OpOperand *opOperand) {
+    assert(opOperand->getOperandNumber() >= getNumDynamicControlOperands() &&
+           "invalid operand");
+    return getOperation()->getOpResult(
+        opOperand->getOperandNumber() - getNumDynamicControlOperands());
+  }
+
+  /// Return the num_threads operand that is tied to the given thread id
+  /// block argument.
+  OpOperand *getTiedOpOperand(BlockArgument bbArg) {
+    assert(bbArg.getArgNumber() >= getRank() && "invalid bbArg");
+
+    return &getOperation()->getOpOperand(getNumDynamicControlOperands() +
+                                         bbArg.getArgNumber() - getRank());
+  }
+
+  /// Return the shared_outs operand that is tied to the given OpResult.
+  OpOperand *getTiedOpOperand(OpResult opResult) {
+    assert(opResult.getDefiningOp() == getOperation() && "invalid OpResult");
+    return &getOperation()->getOpOperand(getNumDynamicControlOperands() +
+                                         opResult.getResultNumber());
+  }
+
+  BlockArgument getTiedBlockArgument(OpOperand *opOperand) {
+    assert(opOperand->getOperandNumber() >= getNumDynamicControlOperands() &&
+           "invalid operand");
+
+    return getBody()->getArgument(opOperand->getOperandNumber() -
+                                  getNumDynamicControlOperands() + getRank());
+  }
+
+  ArrayRef<BlockArgument> getOutputBlockArguments() {
+    return getBody()->getArguments().drop_front(getRank());
+  }
+
+  ::mlir::ValueRange getInductionVars() {
+    return getBody()->getArguments().take_front(getRank());
+  }
+
+  ::mlir::Value getInductionVar(int64_t idx) {
+    return getInductionVars()[idx];
+  }
+
+  ::mlir::Block::BlockArgListType getRegionOutArgs() {
+    return getBody()->getArguments().drop_front(getRank());
+  }
+
+  /// Checks if the lbs are zeros and steps are ones.
+  bool isNormalized();
+
+  // The ensureTerminator method generated by SingleBlockImplicitTerminator is
+  // unaware of the fact that our terminator also needs a region to be
+  // well-formed. We override it here to ensure that we do the right thing.
+  static void ensureTerminator(Region & region, OpBuilder & builder,
+                               Location loc);
+
+  InParallelOp getTerminator();
+
+  // Declare the shared_outs as inits/outs to DestinationStyleOpInterface.
+  MutableOperandRange getDpsInitsMutable() { return getOutputsMutable(); }
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ForallOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::IfOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class IfOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  IfOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  IfOpGenericAdaptorBase(IfOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getThenRegion();
+  ::mlir::Region &getElseRegion();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class IfOpGenericAdaptor : public detail::IfOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::IfOpGenericAdaptorBase;
+public:
+  IfOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  IfOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : IfOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = IfOp, typename = std::enable_if_t<std::is_same_v<LateInst, IfOp>>>
+  IfOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  ValueT getCondition() {
+    return (*getODSOperands(0).begin());
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class IfOpAdaptor : public IfOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using IfOpGenericAdaptor::IfOpGenericAdaptor;
+  IfOpAdaptor(IfOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class IfOp : public ::mlir::Op<IfOp, ::mlir::OpTrait::NRegions<2>::Impl, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<scf::YieldOp>::Impl, ::mlir::OpTrait::NoRegionArguments, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpTrait::InferTypeOpAdaptor, ::mlir::OpTrait::HasRecursiveMemoryEffects> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = IfOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = IfOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.if");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::TypedValue<::mlir::IntegerType> getCondition();
+  ::mlir::OpOperand &getConditionMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Operation::result_range getResults();
+  ::mlir::Region &getThenRegion();
+  ::mlir::Region &getElseRegion();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange resultTypes, Value cond);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange resultTypes, Value cond, bool addThenBlock, bool addElseBlock);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value cond, bool withElseRegion);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange resultTypes, Value cond, bool withElseRegion);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value cond, function_ref<void(OpBuilder &, Location)> thenBuilder = buildTerminatedBody, function_ref<void(OpBuilder &, Location)> elseBuilder = nullptr);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
+  ::mlir::LogicalResult fold(FoldAdaptor adaptor, ::llvm::SmallVectorImpl<::mlir::OpFoldResult> &results);
+  void getEntrySuccessorRegions(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+  void getRegionInvocationBounds(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::InvocationBounds> &invocationBounds);
+  static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes);
+public:
+      static ::mlir::LogicalResult
+      inferReturnTypes(::mlir::MLIRContext *context,
+                              std::optional<::mlir::Location> location,
+                              Adaptor adaptor,
+                              ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes);
+
+
+  OpBuilder getThenBodyBuilder(OpBuilder::Listener *listener = nullptr) {
+    Block* body = getBody(0);
+    return getResults().empty() ? OpBuilder::atBlockTerminator(body, listener)
+                                : OpBuilder::atBlockEnd(body, listener);
+  }
+  OpBuilder getElseBodyBuilder(OpBuilder::Listener *listener = nullptr) {
+    Block* body = getBody(1);
+    return getResults().empty() ? OpBuilder::atBlockTerminator(body, listener)
+                                : OpBuilder::atBlockEnd(body, listener);
+  }
+  Block* thenBlock();
+  YieldOp thenYield();
+  Block* elseBlock();
+  YieldOp elseYield();
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::IfOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::InParallelOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class InParallelOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  InParallelOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  InParallelOpGenericAdaptorBase(InParallelOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getRegion();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class InParallelOpGenericAdaptor : public detail::InParallelOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::InParallelOpGenericAdaptorBase;
+public:
+  InParallelOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  InParallelOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : InParallelOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = InParallelOp, typename = std::enable_if_t<std::is_same_v<LateInst, InParallelOp>>>
+  InParallelOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class InParallelOpAdaptor : public InParallelOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using InParallelOpGenericAdaptor::InParallelOpGenericAdaptor;
+  InParallelOpAdaptor(InParallelOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class InParallelOp : public ::mlir::Op<InParallelOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::HasParent<ForallOp>::Impl, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator, ::mlir::ParallelCombiningOpInterface::Trait, ::mlir::RegionKindInterface::Trait, ::mlir::OpTrait::HasOnlyGraphRegion> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = InParallelOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = InParallelOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.forall.in_parallel");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Region &getRegion();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
+public:
+  ::llvm::SmallVector<::mlir::BlockArgument> getDests();
+  ::llvm::iterator_range<::mlir::Block::iterator> getYieldingOps();
+  ::mlir::OpResult getParentResult(int64_t idx);
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::InParallelOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::IndexSwitchOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class IndexSwitchOpGenericAdaptorBase {
+public:
+  struct Properties {
+    using casesTy = ::mlir::DenseI64ArrayAttr;
+    casesTy cases;
+
+    auto getCases() {
+      auto &propStorage = this->cases;
+      return ::llvm::cast<::mlir::DenseI64ArrayAttr>(propStorage);
+    }
+    void setCases(const ::mlir::DenseI64ArrayAttr &propValue) {
+      this->cases = propValue;
+    }
+    bool operator==(const Properties &rhs) const {
+      return 
+        rhs.cases == this->cases &&
+        true;
+    }
+    bool operator!=(const Properties &rhs) const {
+      return !(*this == rhs);
+    }
+  };
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  Properties properties;
+  ::mlir::RegionRange odsRegions;
+public:
+  IndexSwitchOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const Properties &properties = {}, ::mlir::RegionRange regions = {});
+
+  IndexSwitchOpGenericAdaptorBase(IndexSwitchOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  const Properties &getProperties() {
+    return properties;
+  }
+
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::DenseI64ArrayAttr getCasesAttr();
+  ::llvm::ArrayRef<int64_t> getCases();
+  ::mlir::Region &getDefaultRegion();
+  ::mlir::RegionRange getCaseRegions();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class IndexSwitchOpGenericAdaptor : public detail::IndexSwitchOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::IndexSwitchOpGenericAdaptorBase;
+public:
+  IndexSwitchOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const Properties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  IndexSwitchOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : IndexSwitchOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
+
+  template <typename LateInst = IndexSwitchOp, typename = std::enable_if_t<std::is_same_v<LateInst, IndexSwitchOp>>>
+  IndexSwitchOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  ValueT getArg() {
+    return (*getODSOperands(0).begin());
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class IndexSwitchOpAdaptor : public IndexSwitchOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using IndexSwitchOpGenericAdaptor::IndexSwitchOpGenericAdaptor;
+  IndexSwitchOpAdaptor(IndexSwitchOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class IndexSwitchOp : public ::mlir::Op<IndexSwitchOp, ::mlir::OpTrait::AtLeastNRegions<1>::Impl, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<scf::YieldOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects, ::mlir::RegionBranchOpInterface::Trait> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = IndexSwitchOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = IndexSwitchOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  using Properties = FoldAdaptor::Properties;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    static ::llvm::StringRef attrNames[] = {::llvm::StringRef("cases")};
+    return ::llvm::ArrayRef(attrNames);
+  }
+
+  ::mlir::StringAttr getCasesAttrName() {
+    return getAttributeNameForIndex(0);
+  }
+
+  static ::mlir::StringAttr getCasesAttrName(::mlir::OperationName name) {
+    return getAttributeNameForIndex(name, 0);
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.index_switch");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::TypedValue<::mlir::IndexType> getArg();
+  ::mlir::OpOperand &getArgMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Operation::result_range getResults();
+  ::mlir::Region &getDefaultRegion();
+  ::mlir::MutableArrayRef<::mlir::Region> getCaseRegions();
+  static ::mlir::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
+  static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
+  static llvm::hash_code computePropertiesHash(const Properties &prop);
+  static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
+  static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
+  static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
+  static ::mlir::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
+  static ::mlir::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
+  void writeProperties(::mlir::DialectBytecodeWriter &writer);
+  ::mlir::DenseI64ArrayAttr getCasesAttr();
+  ::llvm::ArrayRef<int64_t> getCases();
+  void setCasesAttr(::mlir::DenseI64ArrayAttr attr);
+  void setCases(::llvm::ArrayRef<int64_t> attrValue);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange results, ::mlir::Value arg, ::mlir::DenseI64ArrayAttr cases, unsigned caseRegionsCount);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange results, ::mlir::Value arg, ::llvm::ArrayRef<int64_t> cases, unsigned caseRegionsCount);
+  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  void getEntrySuccessorRegions(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+  void getRegionInvocationBounds(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::InvocationBounds> &invocationBounds);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &_odsPrinter);
+private:
+  ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
+    return getAttributeNameForIndex((*this)->getName(), index);
+  }
+
+  static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
+    assert(index < 1 && "invalid attribute index");
+    assert(name.getStringRef() == getOperationName() && "invalid operation name");
+    return name.getAttributeNames()[index];
+  }
+
+public:
+  /// Get the number of cases.
+  unsigned getNumCases();
+
+  /// Get the default region body.
+  Block &getDefaultBlock();
+
+  /// Get the body of a case region.
+  Block &getCaseBlock(unsigned idx);
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::IndexSwitchOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ParallelOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ParallelOpGenericAdaptorBase {
+public:
+  struct Properties {
+    using operandSegmentSizesTy = std::array<int32_t, 4>;
+    operandSegmentSizesTy operandSegmentSizes;
+    ::llvm::ArrayRef<int32_t> getOperandSegmentSizes() {
+      auto &propStorage = this->operandSegmentSizes;
+      return propStorage;
+    }
+    void setOperandSegmentSizes(const ::llvm::ArrayRef<int32_t> &propValue) {
+      auto &propStorage = this->operandSegmentSizes;
+      ::llvm::copy(propValue, propStorage.begin());
+    }
+    bool operator==(const Properties &rhs) const {
+      return 
+        rhs.operandSegmentSizes == this->operandSegmentSizes &&
+        true;
+    }
+    bool operator!=(const Properties &rhs) const {
+      return !(*this == rhs);
+    }
+  };
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  Properties properties;
+  ::mlir::RegionRange odsRegions;
+public:
+  ParallelOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ParallelOpGenericAdaptorBase(ParallelOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  const Properties &getProperties() {
+    return properties;
+  }
+
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getRegion();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class ParallelOpGenericAdaptor : public detail::ParallelOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ParallelOpGenericAdaptorBase;
+public:
+  ParallelOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ParallelOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ParallelOpGenericAdaptor(values, attrs, (properties ? *properties.as<Properties *>() : Properties{}), regions) {}
+
+  template <typename LateInst = ParallelOp, typename = std::enable_if_t<std::is_same_v<LateInst, ParallelOp>>>
+  ParallelOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  RangeT getLowerBound() {
+    return getODSOperands(0);
+  }
+
+  RangeT getUpperBound() {
+    return getODSOperands(1);
+  }
+
+  RangeT getStep() {
+    return getODSOperands(2);
+  }
+
+  RangeT getInitVals() {
+    return getODSOperands(3);
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ParallelOpAdaptor : public ParallelOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ParallelOpGenericAdaptor::ParallelOpGenericAdaptor;
+  ParallelOpAdaptor(ParallelOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ParallelOp : public ::mlir::Op<ParallelOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<scf::YieldOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::AutomaticAllocationScope, ::mlir::LoopLikeOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects, ::mlir::RegionBranchOpInterface::Trait> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ParallelOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ParallelOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  using Properties = FoldAdaptor::Properties;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    static ::llvm::StringRef attrNames[] = {::llvm::StringRef("operandSegmentSizes")};
+    return ::llvm::ArrayRef(attrNames);
+  }
+
+  ::mlir::StringAttr getOperandSegmentSizesAttrName() {
+   return (*this)->getName().getAttributeNames().back();
+  }
+
+  static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) {
+   return name.getAttributeNames().back();
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.parallel");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Operation::operand_range getLowerBound();
+  ::mlir::Operation::operand_range getUpperBound();
+  ::mlir::Operation::operand_range getStep();
+  ::mlir::Operation::operand_range getInitVals();
+  ::mlir::MutableOperandRange getLowerBoundMutable();
+  ::mlir::MutableOperandRange getUpperBoundMutable();
+  ::mlir::MutableOperandRange getStepMutable();
+  ::mlir::MutableOperandRange getInitValsMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Operation::result_range getResults();
+  ::mlir::Region &getRegion();
+  static ::mlir::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
+  static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop);
+  static llvm::hash_code computePropertiesHash(const Properties &prop);
+  static std::optional<mlir::Attribute> getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name);
+  static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value);
+  static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs);
+  static ::mlir::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError);
+  static ::mlir::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state);
+  void writeProperties(::mlir::DialectBytecodeWriter &writer);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange lowerBounds, ValueRange upperBounds, ValueRange steps, ValueRange initVals, function_ref<void (OpBuilder &, Location, ValueRange, ValueRange)> bodyBuilderFn = nullptr);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange lowerBounds, ValueRange upperBounds, ValueRange steps, function_ref<void (OpBuilder &, Location, ValueRange)> bodyBuilderFn = nullptr);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
+  ::llvm::SmallVector<::mlir::Region *> getLoopRegions();
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+private:
+  ::mlir::StringAttr getAttributeNameForIndex(unsigned index) {
+    return getAttributeNameForIndex((*this)->getName(), index);
+  }
+
+  static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) {
+    return {};
+  }
+
+public:
+  ValueRange getInductionVars() {
+    return getBody()->getArguments();
+  }
+  unsigned getNumLoops() { return getStep().size(); }
+  unsigned getNumReductions() { return getInitVals().size(); }
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ParallelOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ReduceOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ReduceOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  ReduceOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ReduceOpGenericAdaptorBase(ReduceOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getReductionOperator();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class ReduceOpGenericAdaptor : public detail::ReduceOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ReduceOpGenericAdaptorBase;
+public:
+  ReduceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ReduceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ReduceOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = ReduceOp, typename = std::enable_if_t<std::is_same_v<LateInst, ReduceOp>>>
+  ReduceOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  ValueT getOperand() {
+    return (*getODSOperands(0).begin());
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ReduceOpAdaptor : public ReduceOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ReduceOpGenericAdaptor::ReduceOpGenericAdaptor;
+  ReduceOpAdaptor(ReduceOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ReduceOp : public ::mlir::Op<ReduceOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::HasParent<ParallelOp>::Impl, ::mlir::OpTrait::OpInvariants> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ReduceOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ReduceOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.reduce");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Value getOperand();
+  ::mlir::OpOperand &getOperandMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Region &getReductionOperator();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value operand, function_ref<void (OpBuilder &, Location, Value, Value)> bodyBuilderFn = nullptr);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verifyRegions();
+public:
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ReduceOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::ReduceReturnOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class ReduceReturnOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  ReduceReturnOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  ReduceReturnOpGenericAdaptorBase(ReduceReturnOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+};
+} // namespace detail
+template <typename RangeT>
+class ReduceReturnOpGenericAdaptor : public detail::ReduceReturnOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::ReduceReturnOpGenericAdaptorBase;
+public:
+  ReduceReturnOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  ReduceReturnOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : ReduceReturnOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = ReduceReturnOp, typename = std::enable_if_t<std::is_same_v<LateInst, ReduceReturnOp>>>
+  ReduceReturnOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  ValueT getResult() {
+    return (*getODSOperands(0).begin());
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class ReduceReturnOpAdaptor : public ReduceReturnOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using ReduceReturnOpGenericAdaptor::ReduceReturnOpGenericAdaptor;
+  ReduceReturnOpAdaptor(ReduceReturnOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class ReduceReturnOp : public ::mlir::Op<ReduceReturnOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::HasParent<ReduceOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = ReduceReturnOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = ReduceReturnOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.reduce.return");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Value getResult();
+  ::mlir::OpOperand &getResultMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value result);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value result);
+  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &_odsPrinter);
+  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
+public:
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::ReduceReturnOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::WhileOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class WhileOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  WhileOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  WhileOpGenericAdaptorBase(WhileOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+  ::mlir::Region &getBefore();
+  ::mlir::Region &getAfter();
+  ::mlir::RegionRange getRegions();
+};
+} // namespace detail
+template <typename RangeT>
+class WhileOpGenericAdaptor : public detail::WhileOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::WhileOpGenericAdaptorBase;
+public:
+  WhileOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  WhileOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : WhileOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = WhileOp, typename = std::enable_if_t<std::is_same_v<LateInst, WhileOp>>>
+  WhileOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  RangeT getInits() {
+    return getODSOperands(0);
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class WhileOpAdaptor : public WhileOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using WhileOpGenericAdaptor::WhileOpGenericAdaptor;
+  WhileOpAdaptor(WhileOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class WhileOp : public ::mlir::Op<WhileOp, ::mlir::OpTrait::NRegions<2>::Impl, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchOpInterface::Trait, ::mlir::LoopLikeOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = WhileOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = WhileOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.while");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Operation::operand_range getInits();
+  ::mlir::MutableOperandRange getInitsMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  ::mlir::Operation::result_range getResults();
+  ::mlir::Region &getBefore();
+  ::mlir::Region &getAfter();
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange resultTypes, ValueRange operands, function_ref<void(OpBuilder &, Location, ValueRange)> beforeBuilder, function_ref<void(OpBuilder &, Location, ValueRange)> afterBuilder);
+  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &p);
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::LogicalResult verify();
+  static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context);
+  ::mlir::OperandRange getEntrySuccessorOperands(::mlir::RegionBranchPoint point);
+  void getSuccessorRegions(::mlir::RegionBranchPoint point, ::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &regions);
+  ::llvm::SmallVector<::mlir::Region *> getLoopRegions();
+  ::mlir::Block::BlockArgListType getRegionIterArgs();
+public:
+  using BodyBuilderFn =
+      function_ref<void(OpBuilder &, Location, ValueRange)>;
+
+  ConditionOp getConditionOp();
+  YieldOp getYieldOp();
+  Block::BlockArgListType getBeforeArguments();
+  Block::BlockArgListType getAfterArguments();
+  Block *getBeforeBody() { return &getBefore().front(); }
+  Block *getAfterBody() { return &getAfter().front(); }
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::WhileOp)
+
+namespace mlir {
+namespace scf {
+
+//===----------------------------------------------------------------------===//
+// ::mlir::scf::YieldOp declarations
+//===----------------------------------------------------------------------===//
+
+namespace detail {
+class YieldOpGenericAdaptorBase {
+public:
+protected:
+  ::mlir::DictionaryAttr odsAttrs;
+  ::std::optional<::mlir::OperationName> odsOpName;
+  ::mlir::RegionRange odsRegions;
+public:
+  YieldOpGenericAdaptorBase(::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {});
+
+  YieldOpGenericAdaptorBase(YieldOp op);
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize);
+  ::mlir::DictionaryAttr getAttributes();
+};
+} // namespace detail
+template <typename RangeT>
+class YieldOpGenericAdaptor : public detail::YieldOpGenericAdaptorBase {
+  using ValueT = ::llvm::detail::ValueOfRange<RangeT>;
+  using Base = detail::YieldOpGenericAdaptorBase;
+public:
+  YieldOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr, const ::mlir::EmptyProperties &properties = {}, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {}
+
+  YieldOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions = {}) : YieldOpGenericAdaptor(values, attrs, (properties ? *properties.as<::mlir::EmptyProperties *>() : ::mlir::EmptyProperties{}), regions) {}
+
+  template <typename LateInst = YieldOp, typename = std::enable_if_t<std::is_same_v<LateInst, YieldOp>>>
+  YieldOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {}
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index) {
+    return Base::getODSOperandIndexAndLength(index, odsOperands.size());
+  }
+
+  RangeT getODSOperands(unsigned index) {
+    auto valueRange = getODSOperandIndexAndLength(index);
+    return {std::next(odsOperands.begin(), valueRange.first),
+             std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
+  }
+
+  RangeT getResults() {
+    return getODSOperands(0);
+  }
+
+  RangeT getOperands() {
+    return odsOperands;
+  }
+
+private:
+  RangeT odsOperands;
+};
+class YieldOpAdaptor : public YieldOpGenericAdaptor<::mlir::ValueRange> {
+public:
+  using YieldOpGenericAdaptor::YieldOpGenericAdaptor;
+  YieldOpAdaptor(YieldOp op);
+
+  ::mlir::LogicalResult verify(::mlir::Location loc);
+};
+class YieldOp : public ::mlir::Op<YieldOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::HasParent<ExecuteRegionOp, ForOp, IfOp, IndexSwitchOp, ParallelOp, WhileOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::OpTrait::ReturnLike, ::mlir::OpTrait::IsTerminator> {
+public:
+  using Op::Op;
+  using Op::print;
+  using Adaptor = YieldOpAdaptor;
+  template <typename RangeT>
+  using GenericAdaptor = YieldOpGenericAdaptor<RangeT>;
+  using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>;
+  static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() {
+    return {};
+  }
+
+  static constexpr ::llvm::StringLiteral getOperationName() {
+    return ::llvm::StringLiteral("scf.yield");
+  }
+
+  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);
+  ::mlir::Operation::operand_range getODSOperands(unsigned index);
+  ::mlir::Operation::operand_range getResults();
+  ::mlir::MutableOperandRange getResultsMutable();
+  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);
+  ::mlir::Operation::result_range getODSResults(unsigned index);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState);
+  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange results);
+  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+  ::mlir::LogicalResult verifyInvariantsImpl();
+  ::mlir::LogicalResult verifyInvariants();
+  ::mlir::MutableOperandRange getMutableSuccessorOperands(::mlir::RegionBranchPoint point);
+  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+  void print(::mlir::OpAsmPrinter &_odsPrinter);
+  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects);
+public:
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::YieldOp)
+
+
+#endif  // GET_OP_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/SCFOpsDialect.cpp.inc

@@ -0,0 +1,25 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Dialect Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SCFOps.td                                                            *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::scf::SCFDialect)
+namespace mlir {
+namespace scf {
+
+SCFDialect::SCFDialect(::mlir::MLIRContext *context)
+    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<SCFDialect>()) {
+  
+    getContext()->loadDialect<arith::ArithDialect>();
+
+  initialize();
+}
+
+SCFDialect::~SCFDialect() = default;
+
+} // namespace scf
+} // namespace mlir

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/SCFOpsDialect.h.inc

@@ -0,0 +1,26 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Dialect Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SCFOps.td                                                            *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+namespace mlir {
+namespace scf {
+
+class SCFDialect : public ::mlir::Dialect {
+  explicit SCFDialect(::mlir::MLIRContext *context);
+
+  void initialize();
+  friend class ::mlir::MLIRContext;
+public:
+  ~SCFDialect() override;
+  static constexpr ::llvm::StringLiteral getDialectNamespace() {
+    return ::llvm::StringLiteral("scf");
+  }
+};
+} // namespace scf
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::scf::SCFDialect)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/IR/ValueBoundsOpInterfaceImpl.h

@@ -0,0 +1,20 @@
+//===- ValueBoundsOpInterfaceImpl.h - Impl. of ValueBoundsOpInterface -----===//
+//
+// 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_SCF_IR_VALUEBOUNDSOPINTERFACEIMPL_H
+#define MLIR_DIALECT_SCF_IR_VALUEBOUNDSOPINTERFACEIMPL_H
+
+namespace mlir {
+class DialectRegistry;
+
+namespace scf {
+void registerValueBoundsOpInterfaceExternalModels(DialectRegistry &registry);
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_IR_VALUEBOUNDSOPINTERFACEIMPL_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/BufferDeallocationOpInterfaceImpl.h

@@ -0,0 +1,22 @@
+//===- BufferDeallocationOpInterfaceImpl.h ----------------------*- 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_SCF_TRANSFORMS_BUFFERDEALLOCATIONOPINTERFACEIMPL_H
+#define MLIR_DIALECT_SCF_TRANSFORMS_BUFFERDEALLOCATIONOPINTERFACEIMPL_H
+
+namespace mlir {
+
+class DialectRegistry;
+
+namespace scf {
+void registerBufferDeallocationOpInterfaceExternalModels(
+    DialectRegistry &registry);
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_TRANSFORMS_BUFFERDEALLOCATIONOPINTERFACEIMPL_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.h

@@ -0,0 +1,20 @@
+//===- BufferizableOpInterfaceImpl.h - Impl. of BufferizableOpInterface ---===//
+//
+// 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_SCF_TRANSFORMS_BUFFERIZABLEOPINTERFACEIMPL_H
+#define MLIR_DIALECT_SCF_TRANSFORMS_BUFFERIZABLEOPINTERFACEIMPL_H
+
+namespace mlir {
+class DialectRegistry;
+
+namespace scf {
+void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_BUFFERIZABLEOPINTERFACEIMPL_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/Passes.h

@@ -0,0 +1,75 @@
+//===- Passes.h - Pass Entrypoints ------------------------------*- 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 header file defines prototypes that expose pass constructors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_
+#define MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_
+
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+#define GEN_PASS_DECL
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+
+/// Creates a pass that bufferizes the SCF dialect.
+std::unique_ptr<Pass> createSCFBufferizePass();
+
+/// Creates a pass that specializes for loop for unrolling and
+/// vectorization.
+std::unique_ptr<Pass> createForLoopSpecializationPass();
+
+/// Creates a pass that peels for loops at their upper bounds for
+/// better vectorization.
+std::unique_ptr<Pass> createForLoopPeelingPass();
+
+/// Creates a pass that canonicalizes affine.min and affine.max operations
+/// inside of scf.for loops with known lower and upper bounds.
+std::unique_ptr<Pass> createSCFForLoopCanonicalizationPass();
+
+/// Creates a pass that transforms a single ParallelLoop over N induction
+/// variables into another ParallelLoop over less than N induction variables.
+std::unique_ptr<Pass> createTestSCFParallelLoopCollapsingPass();
+
+/// Creates a loop fusion pass which fuses parallel loops.
+std::unique_ptr<Pass> createParallelLoopFusionPass();
+
+/// Creates a pass that specializes parallel loop for unrolling and
+/// vectorization.
+std::unique_ptr<Pass> createParallelLoopSpecializationPass();
+
+/// Creates a pass which tiles innermost parallel loops.
+/// If noMinMaxBounds, the upper bound of the inner loop will
+/// be a same value among different outter loop iterations, and
+/// an additional inbound check will be emitted inside the internal
+/// loops.
+std::unique_ptr<Pass>
+createParallelLoopTilingPass(llvm::ArrayRef<int64_t> tileSize = {},
+                             bool noMinMaxBounds = false);
+
+/// Creates a pass which folds arith ops on induction variable into
+/// loop range.
+std::unique_ptr<Pass> createForLoopRangeFoldingPass();
+
+// Creates a pass which lowers for loops into while loops.
+std::unique_ptr<Pass> createForToWhileLoopPass();
+
+//===----------------------------------------------------------------------===//
+// Registration
+//===----------------------------------------------------------------------===//
+
+/// Generate the code for registering passes.
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/Passes.h.inc

@@ -0,0 +1,1304 @@
+/* Autogenerated by mlir-tblgen; don't manually edit */
+
+#ifdef GEN_PASS_DECL
+// Generate declarations for all passes.
+#define GEN_PASS_DECL_SCFBUFFERIZE
+#define GEN_PASS_DECL_SCFFORLOOPCANONICALIZATION
+#define GEN_PASS_DECL_SCFFORLOOPPEELING
+#define GEN_PASS_DECL_SCFFORLOOPRANGEFOLDING
+#define GEN_PASS_DECL_SCFFORLOOPSPECIALIZATION
+#define GEN_PASS_DECL_SCFFORTOWHILELOOP
+#define GEN_PASS_DECL_SCFPARALLELLOOPFUSION
+#define GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATION
+#define GEN_PASS_DECL_SCFPARALLELLOOPTILING
+#define GEN_PASS_DECL_TESTSCFPARALLELLOOPCOLLAPSING
+#undef GEN_PASS_DECL
+#endif // GEN_PASS_DECL
+
+//===----------------------------------------------------------------------===//
+// SCFBufferize
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFBUFFERIZE
+#undef GEN_PASS_DECL_SCFBUFFERIZE
+#endif // GEN_PASS_DECL_SCFBUFFERIZE
+#ifdef GEN_PASS_DEF_SCFBUFFERIZE
+namespace impl {
+
+template <typename DerivedT>
+class SCFBufferizeBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFBufferizeBase;
+
+  SCFBufferizeBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFBufferizeBase(const SCFBufferizeBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-bufferize");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-bufferize"; }
+
+  ::llvm::StringRef getDescription() const override { return "Bufferize the scf dialect."; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFBufferize");
+  }
+  ::llvm::StringRef getName() const override { return "SCFBufferize"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFBufferizeBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFBUFFERIZE
+#endif // GEN_PASS_DEF_SCFBUFFERIZE
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopCanonicalization
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFFORLOOPCANONICALIZATION
+#undef GEN_PASS_DECL_SCFFORLOOPCANONICALIZATION
+#endif // GEN_PASS_DECL_SCFFORLOOPCANONICALIZATION
+#ifdef GEN_PASS_DEF_SCFFORLOOPCANONICALIZATION
+namespace impl {
+
+template <typename DerivedT>
+class SCFForLoopCanonicalizationBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopCanonicalizationBase;
+
+  SCFForLoopCanonicalizationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopCanonicalizationBase(const SCFForLoopCanonicalizationBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-canonicalization");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-canonicalization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Canonicalize operations within scf.for loop bodies"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopCanonicalization");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopCanonicalization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  registry.insert<tensor::TensorDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopCanonicalizationBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFFORLOOPCANONICALIZATION
+#endif // GEN_PASS_DEF_SCFFORLOOPCANONICALIZATION
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopPeeling
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFFORLOOPPEELING
+struct SCFForLoopPeelingOptions {
+  bool skipPartial = true;
+};
+#undef GEN_PASS_DECL_SCFFORLOOPPEELING
+#endif // GEN_PASS_DECL_SCFFORLOOPPEELING
+#ifdef GEN_PASS_DEF_SCFFORLOOPPEELING
+namespace impl {
+
+template <typename DerivedT>
+class SCFForLoopPeelingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopPeelingBase;
+
+  SCFForLoopPeelingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopPeelingBase(const SCFForLoopPeelingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-peeling");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-peeling"; }
+
+  ::llvm::StringRef getDescription() const override { return "Peel `for` loops at their upper bounds."; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopPeeling");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopPeeling"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopPeelingBase<DerivedT>)
+
+  SCFForLoopPeelingBase(const SCFForLoopPeelingOptions &options) : SCFForLoopPeelingBase() {
+    skipPartial = options.skipPartial;
+  }
+protected:
+  ::mlir::Pass::Option<bool> skipPartial{*this, "skip-partial", ::llvm::cl::desc("Do not peel loops inside of the last, partial iteration of another already peeled loop."), ::llvm::cl::init(true)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFFORLOOPPEELING
+#endif // GEN_PASS_DEF_SCFFORLOOPPEELING
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopRangeFolding
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFFORLOOPRANGEFOLDING
+#undef GEN_PASS_DECL_SCFFORLOOPRANGEFOLDING
+#endif // GEN_PASS_DECL_SCFFORLOOPRANGEFOLDING
+#ifdef GEN_PASS_DEF_SCFFORLOOPRANGEFOLDING
+namespace impl {
+
+template <typename DerivedT>
+class SCFForLoopRangeFoldingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopRangeFoldingBase;
+
+  SCFForLoopRangeFoldingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopRangeFoldingBase(const SCFForLoopRangeFoldingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-range-folding");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-range-folding"; }
+
+  ::llvm::StringRef getDescription() const override { return "Fold add/mul ops into loop range"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopRangeFolding");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopRangeFolding"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopRangeFoldingBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFFORLOOPRANGEFOLDING
+#endif // GEN_PASS_DEF_SCFFORLOOPRANGEFOLDING
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopSpecialization
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFFORLOOPSPECIALIZATION
+#undef GEN_PASS_DECL_SCFFORLOOPSPECIALIZATION
+#endif // GEN_PASS_DECL_SCFFORLOOPSPECIALIZATION
+#ifdef GEN_PASS_DEF_SCFFORLOOPSPECIALIZATION
+namespace impl {
+
+template <typename DerivedT>
+class SCFForLoopSpecializationBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopSpecializationBase;
+
+  SCFForLoopSpecializationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopSpecializationBase(const SCFForLoopSpecializationBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-specialization");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-specialization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Specialize `for` loops for vectorization"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopSpecialization");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopSpecialization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopSpecializationBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFFORLOOPSPECIALIZATION
+#endif // GEN_PASS_DEF_SCFFORLOOPSPECIALIZATION
+
+//===----------------------------------------------------------------------===//
+// SCFForToWhileLoop
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFFORTOWHILELOOP
+#undef GEN_PASS_DECL_SCFFORTOWHILELOOP
+#endif // GEN_PASS_DECL_SCFFORTOWHILELOOP
+#ifdef GEN_PASS_DEF_SCFFORTOWHILELOOP
+namespace impl {
+
+template <typename DerivedT>
+class SCFForToWhileLoopBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForToWhileLoopBase;
+
+  SCFForToWhileLoopBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForToWhileLoopBase(const SCFForToWhileLoopBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-to-while");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-to-while"; }
+
+  ::llvm::StringRef getDescription() const override { return "Convert SCF for loops to SCF while loops"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForToWhileLoop");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForToWhileLoop"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForToWhileLoopBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFFORTOWHILELOOP
+#endif // GEN_PASS_DEF_SCFFORTOWHILELOOP
+
+//===----------------------------------------------------------------------===//
+// SCFParallelLoopFusion
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFPARALLELLOOPFUSION
+#undef GEN_PASS_DECL_SCFPARALLELLOOPFUSION
+#endif // GEN_PASS_DECL_SCFPARALLELLOOPFUSION
+#ifdef GEN_PASS_DEF_SCFPARALLELLOOPFUSION
+namespace impl {
+
+template <typename DerivedT>
+class SCFParallelLoopFusionBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFParallelLoopFusionBase;
+
+  SCFParallelLoopFusionBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFParallelLoopFusionBase(const SCFParallelLoopFusionBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-parallel-loop-fusion");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-parallel-loop-fusion"; }
+
+  ::llvm::StringRef getDescription() const override { return "Fuse adjacent parallel loops"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFParallelLoopFusion");
+  }
+  ::llvm::StringRef getName() const override { return "SCFParallelLoopFusion"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFParallelLoopFusionBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFPARALLELLOOPFUSION
+#endif // GEN_PASS_DEF_SCFPARALLELLOOPFUSION
+
+//===----------------------------------------------------------------------===//
+// SCFParallelLoopSpecialization
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATION
+#undef GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATION
+#endif // GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATION
+#ifdef GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATION
+namespace impl {
+
+template <typename DerivedT>
+class SCFParallelLoopSpecializationBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFParallelLoopSpecializationBase;
+
+  SCFParallelLoopSpecializationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFParallelLoopSpecializationBase(const SCFParallelLoopSpecializationBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-parallel-loop-specialization");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-parallel-loop-specialization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Specialize parallel loops for vectorization"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFParallelLoopSpecialization");
+  }
+  ::llvm::StringRef getName() const override { return "SCFParallelLoopSpecialization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFParallelLoopSpecializationBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATION
+#endif // GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATION
+
+//===----------------------------------------------------------------------===//
+// SCFParallelLoopTiling
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SCFPARALLELLOOPTILING
+struct SCFParallelLoopTilingOptions {
+  ::llvm::ArrayRef<int64_t> tileSizes;
+  bool noMinMaxBounds = false;
+};
+#undef GEN_PASS_DECL_SCFPARALLELLOOPTILING
+#endif // GEN_PASS_DECL_SCFPARALLELLOOPTILING
+#ifdef GEN_PASS_DEF_SCFPARALLELLOOPTILING
+namespace impl {
+
+template <typename DerivedT>
+class SCFParallelLoopTilingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFParallelLoopTilingBase;
+
+  SCFParallelLoopTilingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFParallelLoopTilingBase(const SCFParallelLoopTilingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-parallel-loop-tiling");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-parallel-loop-tiling"; }
+
+  ::llvm::StringRef getDescription() const override { return "Tile parallel loops"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFParallelLoopTiling");
+  }
+  ::llvm::StringRef getName() const override { return "SCFParallelLoopTiling"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFParallelLoopTilingBase<DerivedT>)
+
+  SCFParallelLoopTilingBase(const SCFParallelLoopTilingOptions &options) : SCFParallelLoopTilingBase() {
+    tileSizes = options.tileSizes;
+    noMinMaxBounds = options.noMinMaxBounds;
+  }
+protected:
+  ::mlir::Pass::ListOption<int64_t> tileSizes{*this, "parallel-loop-tile-sizes", ::llvm::cl::desc("Factors to tile parallel loops by")};
+  ::mlir::Pass::Option<bool> noMinMaxBounds{*this, "no-min-max-bounds", ::llvm::cl::desc("Perform tiling with fixed upper bound with inbound check inside the internal loops"), ::llvm::cl::init(false)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SCFPARALLELLOOPTILING
+#endif // GEN_PASS_DEF_SCFPARALLELLOOPTILING
+
+//===----------------------------------------------------------------------===//
+// TestSCFParallelLoopCollapsing
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_TESTSCFPARALLELLOOPCOLLAPSING
+struct TestSCFParallelLoopCollapsingOptions {
+  ::llvm::ArrayRef<unsigned> clCollapsedIndices0;
+  ::llvm::ArrayRef<unsigned> clCollapsedIndices1;
+  ::llvm::ArrayRef<unsigned> clCollapsedIndices2;
+};
+#undef GEN_PASS_DECL_TESTSCFPARALLELLOOPCOLLAPSING
+#endif // GEN_PASS_DECL_TESTSCFPARALLELLOOPCOLLAPSING
+#ifdef GEN_PASS_DEF_TESTSCFPARALLELLOOPCOLLAPSING
+namespace impl {
+
+template <typename DerivedT>
+class TestSCFParallelLoopCollapsingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = TestSCFParallelLoopCollapsingBase;
+
+  TestSCFParallelLoopCollapsingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  TestSCFParallelLoopCollapsingBase(const TestSCFParallelLoopCollapsingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("test-scf-parallel-loop-collapsing");
+  }
+  ::llvm::StringRef getArgument() const override { return "test-scf-parallel-loop-collapsing"; }
+
+  ::llvm::StringRef getDescription() const override { return "Test parallel loops collapsing transformation"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("TestSCFParallelLoopCollapsing");
+  }
+  ::llvm::StringRef getName() const override { return "TestSCFParallelLoopCollapsing"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSCFParallelLoopCollapsingBase<DerivedT>)
+
+  TestSCFParallelLoopCollapsingBase(const TestSCFParallelLoopCollapsingOptions &options) : TestSCFParallelLoopCollapsingBase() {
+    clCollapsedIndices0 = options.clCollapsedIndices0;
+    clCollapsedIndices1 = options.clCollapsedIndices1;
+    clCollapsedIndices2 = options.clCollapsedIndices2;
+  }
+protected:
+  ::mlir::Pass::ListOption<unsigned> clCollapsedIndices0{*this, "collapsed-indices-0", ::llvm::cl::desc("Which loop indices to combine 0th loop index")};
+  ::mlir::Pass::ListOption<unsigned> clCollapsedIndices1{*this, "collapsed-indices-1", ::llvm::cl::desc("Which loop indices to combine into the position 1 loop index")};
+  ::mlir::Pass::ListOption<unsigned> clCollapsedIndices2{*this, "collapsed-indices-2", ::llvm::cl::desc("Which loop indices to combine into the position 2 loop index")};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_TESTSCFPARALLELLOOPCOLLAPSING
+#endif // GEN_PASS_DEF_TESTSCFPARALLELLOOPCOLLAPSING
+#ifdef GEN_PASS_REGISTRATION
+
+//===----------------------------------------------------------------------===//
+// SCFBufferize Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFBufferize() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSCFBufferizePass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFBufferizePass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSCFBufferizePass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopCanonicalization Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFForLoopCanonicalization() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSCFForLoopCanonicalizationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFForLoopCanonicalizationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSCFForLoopCanonicalizationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopPeeling Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFForLoopPeeling() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForLoopPeelingPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFForLoopPeelingPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForLoopPeelingPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopRangeFolding Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFForLoopRangeFolding() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForLoopRangeFoldingPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFForLoopRangeFoldingPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForLoopRangeFoldingPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFForLoopSpecialization Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFForLoopSpecialization() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForLoopSpecializationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFForLoopSpecializationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForLoopSpecializationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFForToWhileLoop Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFForToWhileLoop() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForToWhileLoopPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFForToWhileLoopPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createForToWhileLoopPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFParallelLoopFusion Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFParallelLoopFusion() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createParallelLoopFusionPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFParallelLoopFusionPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createParallelLoopFusionPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFParallelLoopSpecialization Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFParallelLoopSpecialization() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createParallelLoopSpecializationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFParallelLoopSpecializationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createParallelLoopSpecializationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCFParallelLoopTiling Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFParallelLoopTiling() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createParallelLoopTilingPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSCFParallelLoopTilingPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createParallelLoopTilingPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// TestSCFParallelLoopCollapsing Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerTestSCFParallelLoopCollapsing() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createTestSCFParallelLoopCollapsingPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerTestSCFParallelLoopCollapsingPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createTestSCFParallelLoopCollapsingPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SCF Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSCFPasses() {
+  registerSCFBufferize();
+  registerSCFForLoopCanonicalization();
+  registerSCFForLoopPeeling();
+  registerSCFForLoopRangeFolding();
+  registerSCFForLoopSpecialization();
+  registerSCFForToWhileLoop();
+  registerSCFParallelLoopFusion();
+  registerSCFParallelLoopSpecialization();
+  registerSCFParallelLoopTiling();
+  registerTestSCFParallelLoopCollapsing();
+}
+#undef GEN_PASS_REGISTRATION
+#endif // GEN_PASS_REGISTRATION
+// Deprecated. Please use the new per-pass macros.
+#ifdef GEN_PASS_CLASSES
+
+template <typename DerivedT>
+class SCFBufferizeBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFBufferizeBase;
+
+  SCFBufferizeBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFBufferizeBase(const SCFBufferizeBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-bufferize");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-bufferize"; }
+
+  ::llvm::StringRef getDescription() const override { return "Bufferize the scf dialect."; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFBufferize");
+  }
+  ::llvm::StringRef getName() const override { return "SCFBufferize"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFBufferizeBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFForLoopCanonicalizationBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopCanonicalizationBase;
+
+  SCFForLoopCanonicalizationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopCanonicalizationBase(const SCFForLoopCanonicalizationBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-canonicalization");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-canonicalization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Canonicalize operations within scf.for loop bodies"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopCanonicalization");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopCanonicalization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  registry.insert<tensor::TensorDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopCanonicalizationBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFForLoopPeelingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopPeelingBase;
+
+  SCFForLoopPeelingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopPeelingBase(const SCFForLoopPeelingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-peeling");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-peeling"; }
+
+  ::llvm::StringRef getDescription() const override { return "Peel `for` loops at their upper bounds."; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopPeeling");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopPeeling"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopPeelingBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<bool> skipPartial{*this, "skip-partial", ::llvm::cl::desc("Do not peel loops inside of the last, partial iteration of another already peeled loop."), ::llvm::cl::init(true)};
+};
+
+template <typename DerivedT>
+class SCFForLoopRangeFoldingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopRangeFoldingBase;
+
+  SCFForLoopRangeFoldingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopRangeFoldingBase(const SCFForLoopRangeFoldingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-range-folding");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-range-folding"; }
+
+  ::llvm::StringRef getDescription() const override { return "Fold add/mul ops into loop range"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopRangeFolding");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopRangeFolding"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopRangeFoldingBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFForLoopSpecializationBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForLoopSpecializationBase;
+
+  SCFForLoopSpecializationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForLoopSpecializationBase(const SCFForLoopSpecializationBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-loop-specialization");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-loop-specialization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Specialize `for` loops for vectorization"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForLoopSpecialization");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForLoopSpecialization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForLoopSpecializationBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFForToWhileLoopBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFForToWhileLoopBase;
+
+  SCFForToWhileLoopBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFForToWhileLoopBase(const SCFForToWhileLoopBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-for-to-while");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-for-to-while"; }
+
+  ::llvm::StringRef getDescription() const override { return "Convert SCF for loops to SCF while loops"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFForToWhileLoop");
+  }
+  ::llvm::StringRef getName() const override { return "SCFForToWhileLoop"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFForToWhileLoopBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFParallelLoopFusionBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFParallelLoopFusionBase;
+
+  SCFParallelLoopFusionBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFParallelLoopFusionBase(const SCFParallelLoopFusionBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-parallel-loop-fusion");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-parallel-loop-fusion"; }
+
+  ::llvm::StringRef getDescription() const override { return "Fuse adjacent parallel loops"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFParallelLoopFusion");
+  }
+  ::llvm::StringRef getName() const override { return "SCFParallelLoopFusion"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFParallelLoopFusionBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFParallelLoopSpecializationBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFParallelLoopSpecializationBase;
+
+  SCFParallelLoopSpecializationBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFParallelLoopSpecializationBase(const SCFParallelLoopSpecializationBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-parallel-loop-specialization");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-parallel-loop-specialization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Specialize parallel loops for vectorization"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFParallelLoopSpecialization");
+  }
+  ::llvm::StringRef getName() const override { return "SCFParallelLoopSpecialization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFParallelLoopSpecializationBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SCFParallelLoopTilingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = SCFParallelLoopTilingBase;
+
+  SCFParallelLoopTilingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  SCFParallelLoopTilingBase(const SCFParallelLoopTilingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("scf-parallel-loop-tiling");
+  }
+  ::llvm::StringRef getArgument() const override { return "scf-parallel-loop-tiling"; }
+
+  ::llvm::StringRef getDescription() const override { return "Tile parallel loops"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SCFParallelLoopTiling");
+  }
+  ::llvm::StringRef getName() const override { return "SCFParallelLoopTiling"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SCFParallelLoopTilingBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::ListOption<int64_t> tileSizes{*this, "parallel-loop-tile-sizes", ::llvm::cl::desc("Factors to tile parallel loops by")};
+  ::mlir::Pass::Option<bool> noMinMaxBounds{*this, "no-min-max-bounds", ::llvm::cl::desc("Perform tiling with fixed upper bound with inbound check inside the internal loops"), ::llvm::cl::init(false)};
+};
+
+template <typename DerivedT>
+class TestSCFParallelLoopCollapsingBase : public ::mlir::OperationPass<> {
+public:
+  using Base = TestSCFParallelLoopCollapsingBase;
+
+  TestSCFParallelLoopCollapsingBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
+  TestSCFParallelLoopCollapsingBase(const TestSCFParallelLoopCollapsingBase &other) : ::mlir::OperationPass<>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("test-scf-parallel-loop-collapsing");
+  }
+  ::llvm::StringRef getArgument() const override { return "test-scf-parallel-loop-collapsing"; }
+
+  ::llvm::StringRef getDescription() const override { return "Test parallel loops collapsing transformation"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("TestSCFParallelLoopCollapsing");
+  }
+  ::llvm::StringRef getName() const override { return "TestSCFParallelLoopCollapsing"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestSCFParallelLoopCollapsingBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::ListOption<unsigned> clCollapsedIndices0{*this, "collapsed-indices-0", ::llvm::cl::desc("Which loop indices to combine 0th loop index")};
+  ::mlir::Pass::ListOption<unsigned> clCollapsedIndices1{*this, "collapsed-indices-1", ::llvm::cl::desc("Which loop indices to combine into the position 1 loop index")};
+  ::mlir::Pass::ListOption<unsigned> clCollapsedIndices2{*this, "collapsed-indices-2", ::llvm::cl::desc("Which loop indices to combine into the position 2 loop index")};
+};
+#undef GEN_PASS_CLASSES
+#endif // GEN_PASS_CLASSES

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/Patterns.h

@@ -0,0 +1,85 @@
+//===- Patterns.h - SCF dialect rewrite patterns ----------------*- 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_SCF_TRANSFORMS_PATTERNS_H
+#define MLIR_DIALECT_SCF_TRANSFORMS_PATTERNS_H
+
+#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/SCF/Transforms/Transforms.h"
+#include "mlir/IR/PatternMatch.h"
+
+namespace mlir {
+
+class ConversionTarget;
+class TypeConverter;
+
+namespace scf {
+
+// TODO: such patterns should be auto-generated.
+class ForLoopPipeliningPattern : public OpRewritePattern<ForOp> {
+public:
+  ForLoopPipeliningPattern(const PipeliningOption &options,
+                           MLIRContext *context)
+      : OpRewritePattern<ForOp>(context), options(options) {}
+  LogicalResult matchAndRewrite(ForOp forOp,
+                                PatternRewriter &rewriter) const override {
+    return returningMatchAndRewrite(forOp, rewriter);
+  }
+
+  FailureOr<ForOp> returningMatchAndRewrite(ForOp forOp,
+                                            PatternRewriter &rewriter) const {
+    return pipelineForLoop(rewriter, forOp, options);
+  }
+
+protected:
+  PipeliningOption options;
+};
+
+/// Populates patterns for SCF structural type conversions and sets up the
+/// provided ConversionTarget with the appropriate legality configuration for
+/// the ops to get converted properly.
+///
+/// A "structural" type conversion is one where the underlying ops are
+/// completely agnostic to the actual types involved and simply need to update
+/// their types. An example of this is scf.if -- the scf.if op and the
+/// corresponding scf.yield ops need to update their types accordingly to the
+/// TypeConverter, but otherwise don't care what type conversions are happening.
+void populateSCFStructuralTypeConversionsAndLegality(
+    TypeConverter &typeConverter, RewritePatternSet &patterns,
+    ConversionTarget &target);
+
+/// Similar to `populateSCFStructuralTypeConversionsAndLegality` but does not
+/// populate the conversion target.
+void populateSCFStructuralTypeConversions(TypeConverter &typeConverter,
+                                          RewritePatternSet &patterns);
+
+/// Updates the ConversionTarget with dynamic legality of SCF operations based
+/// on the provided type converter.
+void populateSCFStructuralTypeConversionTarget(
+    const TypeConverter &typeConverter, ConversionTarget &target);
+
+/// Populates the provided pattern set with patterns that do 1:N type
+/// conversions on (some) SCF ops. This is intended to be used with
+/// applyPartialOneToNConversion.
+void populateSCFStructuralOneToNTypeConversions(TypeConverter &typeConverter,
+                                                RewritePatternSet &patterns);
+
+/// Populate patterns for SCF software pipelining transformation. See the
+/// ForLoopPipeliningPattern for the transformation details.
+void populateSCFLoopPipeliningPatterns(RewritePatternSet &patterns,
+                                       const PipeliningOption &options);
+
+/// Populate patterns for canonicalizing operations inside SCF loop bodies.
+/// At the moment, only affine.min/max computations with iteration variables,
+/// loop bounds and loop steps are canonicalized.
+void populateSCFForLoopCanonicalizationPatterns(RewritePatternSet &patterns);
+
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_TRANSFORMS_PATTERNS_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/TileUsingInterface.h

@@ -0,0 +1,246 @@
+//===- TileUsingInterface.h - Tiling ops using TilingInterface --*- 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_SCF_TRANSFORMS_TILEUSINGINTERFACE_H
+#define MLIR_DIALECT_SCF_TRANSFORMS_TILEUSINGINTERFACE_H
+
+#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/Tensor/Transforms/Transforms.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Interfaces/TilingInterface.h"
+
+#include <deque>
+
+namespace mlir {
+class Operation;
+class RewriterBase;
+class TilingInterface;
+} // namespace mlir
+
+namespace mlir {
+namespace scf {
+
+using SCFTileSizeComputationFunction =
+    std::function<SmallVector<OpFoldResult>(OpBuilder &, Operation *)>;
+
+/// Options to use to control tiling.
+struct SCFTilingOptions {
+  /// Computation function that returns the tile sizes for each operation.
+  /// Delayed construction of constant tile sizes should occur to interoperate
+  /// with folding.
+  SCFTileSizeComputationFunction tileSizeComputationFunction = nullptr;
+
+  SCFTilingOptions &
+  setTileSizeComputationFunction(SCFTileSizeComputationFunction fun) {
+    tileSizeComputationFunction = std::move(fun);
+    return *this;
+  }
+  /// Convenience function to set the `tileSizeComputationFunction` to a
+  /// function that computes tile sizes at the point they are needed. Allows
+  /// proper interaction with folding.
+  SCFTilingOptions &setTileSizes(ArrayRef<OpFoldResult> ts);
+
+  /// The interchange vector to reorder the tiled loops.
+  SmallVector<int64_t> interchangeVector = {};
+  SCFTilingOptions &setInterchange(ArrayRef<int64_t> interchange) {
+    interchangeVector = llvm::to_vector(interchange);
+    return *this;
+  }
+};
+
+/// Transformation information returned after tiling.
+struct SCFTilingResult {
+  /// Tiled operations that are generated during tiling. The order does not
+  /// matter except the last op. The replacements are expected to be the results
+  /// of the last op.
+  SmallVector<Operation *> tiledOps;
+  /// The `scf.for` operations that iterate over the tiles.
+  SmallVector<Operation *> loops;
+  /// Values to use as replacements for the untiled op. Is the same size as the
+  /// number of results of the untiled op.
+  SmallVector<Value> replacements;
+};
+
+/// Method to tile an op that implements the `TilingInterface` using
+/// `scf.for` for iterating over the tiles.
+FailureOr<SCFTilingResult> tileUsingSCFForOp(RewriterBase &rewriter,
+                                             TilingInterface op,
+                                             const SCFTilingOptions &options);
+
+/// Options used to control tile + fuse.
+struct SCFTileAndFuseOptions {
+  /// The tiling options used to control the tiling of the consumer.
+  SCFTilingOptions tilingOptions;
+  SCFTileAndFuseOptions &setTilingOptions(SCFTilingOptions options) {
+    tilingOptions = options;
+    return *this;
+  }
+};
+
+/// Fuse the producer of the source of `candidateSliceOp` by computing the
+/// required slice of the producer in-place.  Note that the method
+/// replaces the uses of `candidateSliceOp` with the tiled and fused producer
+/// value but does not delete the slice operation.
+struct SCFFuseProducerOfSliceResult {
+  OpResult origProducer;       // Original untiled producer.
+  Value tiledAndFusedProducer; // Tile and fused producer value.
+  SmallVector<Operation *> tiledOps;
+};
+std::optional<SCFFuseProducerOfSliceResult>
+tileAndFuseProducerOfSlice(RewriterBase &rewriter,
+                           tensor::ExtractSliceOp candidateSliceOp,
+                           MutableArrayRef<scf::ForOp> loops);
+
+/// Reconstruct the fused producer from within the tiled-and-fused code. Based
+/// on the slice of the producer computed in place it is possible that within
+/// the loop nest same slice of the producer is computed multiple times. It is
+/// in general not possible to recompute the value of the fused producer from
+/// the tiled loop code in such cases. For the cases where no slice of the
+/// producer is computed in a redundant fashion it is possible to reconstruct
+/// the value of the original producer from within the tiled loop. It is upto
+/// the caller to ensure that the producer is not computed redundantly within
+/// the tiled loop nest. For example, consider
+///
+/// ```mlir
+/// %0 = linalg.matmul ins(...) outs(...) -> tensor<?x?xf32>
+/// %1 = linalg.matmul ins(%0, ..) outs(...) -> tensor<?x?x?f32>
+/// ```
+///
+/// If `%1` is tiled in a 2D fashion and `%0` is fused with it, the resulting IR
+/// is,
+///
+/// ```mlir
+/// %t1_0 = scf.for .... iter_args(%arg0 = ...) {
+///   %t1_1 = scf.for ... iter_args(%arg1 = %arg0) {
+///     ...
+///     %t1_2 = linalg.matmul ins(...) outs(...) -> tensor<?x?xf32>
+///     %t1_3 = linalg.matmul ins(%t1_2, ...)
+///     %t1_4 = tensor.insert_slice %t1_3 into %arg1 ...
+///     scf.yield %t1_4
+///   }
+///   scf.yield %t1_1
+/// }
+/// ```
+///
+/// Here `%t1_2` is the same for all iterations of the inner `scf.for`. Instead
+/// if `%1` were tiled only along the rows, the resultant code would be
+///
+/// ```mlir
+/// %t2_0 = scf.for .... iter_args(%arg0 = ...) {
+///   ...
+///   %t2_1 = linalg.matmul ins(...) outs(...) -> tensor<?x?xf32>
+///   %t2_2 = linalg.matmul ins(%t2_1, ...)
+///   %t2_3 = tensor.insert_slice %t2_2 into %arg0 ...
+///   scf.yield %t2_3
+/// }
+/// ```
+///
+/// Here there is no intersection in the different slices of `%t2_1` computed
+/// across iterations of the `scf.for`. In such cases, the value of the original
+/// `%0` can be reconstructed from within the loop body. This is useful in cases
+/// where `%0` had other uses as well. If not reconstructed from within the loop
+/// body, uses of `%0` could not be replaced, making it still live and the
+/// fusion immaterial.
+void yieldReplacementForFusedProducer(
+    RewriterBase &rewriter, tensor::ExtractSliceOp sliceOp,
+    scf::SCFFuseProducerOfSliceResult fusedProducerInfo,
+    MutableArrayRef<scf::ForOp> loops);
+
+/// Transformation information returned after tile and fuse.
+struct SCFTileAndFuseResult {
+  /// List of untiled operations that were fused with the tiled consumer.
+  llvm::SetVector<Operation *> fusedProducers;
+  /// List of tiled and fused operations generated. The first one in this list
+  /// is guaranteed to be the tiled operations generated during tiling of the
+  /// generated operation.
+  llvm::SetVector<Operation *> tiledAndFusedOps;
+  /// The `scf.for` operations that iterate over the tiles.
+  SmallVector<Operation *> loops;
+  /// The replacement values to use for the tiled and fused operations.
+  llvm::DenseMap<Value, Value> replacements;
+};
+
+/// Method to tile and fuse a sequence of operations, by tiling the consumer
+/// and fusing its producers. Note that this assumes that it is valid to
+/// tile+fuse the producer into the innermost tiled loop. Its up to the caller
+/// to ensure that the tile sizes provided make this fusion valid.
+///
+/// For example, for the following sequence
+///
+/// ```mlir
+/// %0 =
+/// %1 = linalg.fill ... outs(%0 : ... )
+/// %2 = linalg.matmul ... outs(%1 : ...) ...
+/// ```
+///
+/// it is legal to fuse the fill with the matmul only if the matmul is tiled
+/// along the parallel dimensions and not the reduction dimension, i.e. the tile
+/// size for the reduction dimension should be 0. The resulting fused
+/// transformation is
+///
+/// ```mlir
+/// %1 = scf.for ... iter_args(%arg0 = %0)
+///   %2 = tensor.extract_slice %arg0
+///   %3 = linalg.fill .. outs(%2 : ... )
+///   %4 = linalg.matmul .. outs(%3 : ...)
+/// }
+/// ```
+FailureOr<SCFTileAndFuseResult>
+tileConsumerAndFuseProducerGreedilyUsingSCFForOp(
+    RewriterBase &rewriter, TilingInterface consumer,
+    const SCFTileAndFuseOptions &options);
+
+/// Method to lower an `op` that implements the `TilingInterface` to
+/// loops/scalars.
+FailureOr<SmallVector<scf::ForOp>>
+lowerToLoopsUsingSCFForOp(RewriterBase &rewriter, TilingInterface op);
+
+/// Transformation information returned after reduction tiling.
+struct SCFReductionTilingResult {
+  /// The partial reduction tiled op generated.
+  Operation *parallelTiledOp;
+  /// The final reduction operation merging all the partial reductions.
+  Operation *mergeOp;
+  /// Initial op
+  Operation *initialOp;
+  /// The `scf.for` operations that iterate over the tiles.
+  SmallVector<scf::ForOp> loops;
+};
+
+/// Method to tile a reduction and generate a parallel op within a serial loop.
+/// Each of the partial reductions are calculated in parallel. Then after the
+/// loop all the partial reduction are merged into a final reduction.
+/// For example for the following sequence
+///
+/// ```mlir
+/// %0 = linalg.generic %in ["parallel", "reduction"]
+///   : tensor<7x9xf32> -> tensor<7xf32>
+/// ```
+///
+/// into:
+///
+/// ```mlir
+/// %0 = linalg.fill ... : tensor<7x4xf32>
+/// %1 = scf.for ... iter_args(%arg0 = %0)
+///   %2 = tensor.extract_slice %arg0 : tensor<7x4xf32> -> tensor<7x?xf32>
+///   %3 = tensor.extract_slice %in : tensor<7x9xf32> -> tensor<7x?xf32>
+///   %4 = linalg.generic %2, %3 ["parallel", "parallel"]
+///     : tensor<7x?xf32> -> tensor<7x?xf32>
+///   %5 = tensor.insert_slice %3, %0[0, 0] : tensor<7x4xf32>
+/// }
+/// %6 = linalg.generic %1 ["parallel", "reduction"]
+///   : tensor<7x4xf32> -> tensor<7xf32>
+/// ```
+FailureOr<scf::SCFReductionTilingResult>
+tileReductionUsingScf(RewriterBase &b, PartialReductionOpInterface op,
+                      ArrayRef<OpFoldResult> tileSize);
+
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_TRANSFORMS_TILEUSINGINTERFACE_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Transforms/Transforms.h

@@ -0,0 +1,172 @@
+//===- Transforms.h - SCF dialect transformation utilities ------*- 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 header file defines transformations on SCF operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SCF_TRANSFORMS_TRANSFORMS_H_
+#define MLIR_DIALECT_SCF_TRANSFORMS_TRANSFORMS_H_
+
+#include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+
+namespace mlir {
+
+struct LogicalResult;
+class Region;
+class RewriterBase;
+class Operation;
+class Value;
+
+namespace scf {
+
+class IfOp;
+class ForOp;
+class ParallelOp;
+
+/// Fuses all adjacent scf.parallel operations with identical bounds and step
+/// into one scf.parallel operations. Uses a naive aliasing and dependency
+/// analysis.
+void naivelyFuseParallelOps(Region &region);
+
+/// Rewrite a for loop with bounds/step that potentially do not divide evenly
+/// into a for loop where the step divides the iteration space evenly, followed
+/// by another scf.for for the last (partial) iteration (if any; returned via
+/// `partialIteration`). This transformation is called "loop peeling".
+///
+/// This transformation is beneficial for a wide range of transformations such
+/// as vectorization or loop tiling: It enables additional canonicalizations
+/// inside the peeled loop body such as rewriting masked loads into unmaked
+/// loads.
+///
+/// E.g., assuming a lower bound of 0 (for illustration purposes):
+/// ```
+/// scf.for %iv = %c0 to %ub step %c4 {
+///   (loop body)
+/// }
+/// ```
+/// is rewritten into the following pseudo IR:
+/// ```
+/// %newUb = %ub - (%ub mod %c4)
+/// scf.for %iv = %c0 to %newUb step %c4 {
+///   (loop body)
+/// }
+/// scf.for %iv2 = %newUb to %ub {
+///   (loop body)
+/// }
+/// ```
+///
+/// After loop peeling, this function tries to simplify affine.min and
+/// affine.max ops in the body of the peeled loop and in the body of the partial
+/// iteration loop, taking advantage of the fact that the peeled loop has only
+/// "full" iterations. This simplification is expected to enable further
+/// canonicalization opportunities through other patterns.
+///
+/// The return value indicates whether the loop was rewritten or not. Loops are
+/// not rewritten if:
+/// * Loop step size is 1 or
+/// * Loop bounds and step size are static, and step already divides the
+///   iteration space evenly.
+///
+/// Note: This function rewrites the given scf.for loop in-place and creates a
+/// new scf.for operation for the last iteration. It replaces all uses of the
+/// unpeeled loop with the results of the newly generated scf.for.
+LogicalResult peelForLoopAndSimplifyBounds(RewriterBase &rewriter, ForOp forOp,
+                                           scf::ForOp &partialIteration);
+
+/// Tile a parallel loop of the form
+///   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
+///                                             step (%arg4, %arg5)
+///
+/// into
+///   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
+///                                             step (%arg4*tileSize[0],
+///                                                   %arg5*tileSize[1])
+///     scf.parallel (%j0, %j1) = (0, 0) to (min(tileSize[0], %arg2-%j0)
+///                                           min(tileSize[1], %arg3-%j1))
+///                                        step (%arg4, %arg5)
+/// The old loop is replaced with the new one.
+///
+/// The function returns the resulting ParallelOps, i.e. {outer_loop_op,
+/// inner_loop_op}.
+std::pair<ParallelOp, ParallelOp>
+tileParallelLoop(ParallelOp op, llvm::ArrayRef<int64_t> tileSizes,
+                 bool noMinMaxBounds);
+
+/// Options to dictate how loops should be pipelined.
+struct PipeliningOption {
+  /// Lambda returning all the operation in the forOp, with their stage, in the
+  /// order picked for the pipelined loop.
+  using GetScheduleFnType = std::function<void(
+      scf::ForOp, std::vector<std::pair<Operation *, unsigned>> &)>;
+  GetScheduleFnType getScheduleFn = nullptr;
+  enum class PipelinerPart {
+    Prologue,
+    Kernel,
+    Epilogue,
+  };
+  /// Lambda called by the pipeliner to allow the user to annotate the IR while
+  /// it is generated.
+  /// The callback passes the operation created along with the part of the
+  /// pipeline and the iteration index. The iteration index is always 0 for the
+  /// kernel. For the prologue and epilogue, it corresponds to the iteration
+  /// peeled out of the loop in the range [0, maxStage[.
+  using AnnotationlFnType =
+      std::function<void(Operation *, PipelinerPart, unsigned)>;
+  AnnotationlFnType annotateFn = nullptr;
+
+  /// Control whether the epilogue should be peeled out of the loop or
+  /// operations should be predicated to skip the early stages in the last loop
+  /// iterations. If the epilogue is predicated; the user needs to provide a
+  /// lambda to generate the predicated version of operations.
+  bool peelEpilogue = true;
+
+  // Callback to predicate operations when the prologue or epilogue are not
+  // peeled. This takes the original operation, an i1 predicate value and the
+  // pattern rewriter. It is expected to replace the given operation with
+  // the predicated equivalent and return it, or return nullptr if the
+  // predication is impossible. In the latter case, pipelining will fail and
+  // may leave IR in a partially transformed state.
+  using PredicateOpFn =
+      std::function<Operation *(RewriterBase &, Operation *, Value)>;
+  PredicateOpFn predicateFn = nullptr;
+
+  // TODO: add option to decide if the prologue should be peeled.
+};
+
+/// Generate a pipelined version of the scf.for loop based on the schedule given
+/// as option. This applies the mechanical transformation of changing the loop
+/// and generating the prologue/epilogue for the pipelining and doesn't make any
+/// decision regarding the schedule.
+/// Based on the options the loop is split into several stages.
+/// The transformation assumes that the scheduling given by user is valid.
+/// For example if we break a loop into 3 stages named S0, S1, S2 we would
+/// generate the following code with the number in parenthesis as the iteration
+/// index:
+///
+///   S0(0)                        // Prologue
+///   S0(1) S1(0)                  // Prologue
+///   scf.for %I = %C0 to %N - 2 {
+///     S0(I+2) S1(I+1) S2(I)       // Pipelined kernel
+///   }
+///   S1(N) S2(N-1)                // Epilogue
+///   S2(N)                        // Epilogue
+///
+/// If `modifiedIR` is provided, it will be set to a value that indicates
+/// whether pipelining modified the IR before failing, signaling to the caller
+/// whether they can proceed with different transformations.
+FailureOr<ForOp> pipelineForLoop(RewriterBase &rewriter, ForOp forOp,
+                                 const PipeliningOption &options,
+                                 bool *modifiedIR = nullptr);
+
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_TRANSFORMS_TRANSFORMS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h

@@ -0,0 +1,85 @@
+//===- AffineCanonicalizationUtils.h ----------------------------*- 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 header file defines utility functions to canonicalize affine ops
+// within SCF op regions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
+#define MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
+
+#include "mlir/Support/LLVM.h"
+#include "mlir/Support/LogicalResult.h"
+
+namespace mlir {
+class AffineMap;
+struct LogicalResult;
+class Operation;
+class OpFoldResult;
+class RewriterBase;
+class Value;
+class ValueRange;
+
+namespace affine {
+class FlatAffineValueConstraints;
+} // namespace affine
+
+namespace scf {
+class IfOp;
+
+/// Match "for loop"-like operations: If the first parameter is an iteration
+/// variable, return lower/upper bounds via the second/third parameter and the
+/// step size via the last parameter. The function should return `success` in
+/// that case. If the first parameter is not an iteration variable, return
+/// `failure`.
+using LoopMatcherFn = function_ref<LogicalResult(
+    Value, OpFoldResult &, OpFoldResult &, OpFoldResult &)>;
+
+/// Match "for loop"-like operations from the SCF dialect.
+LogicalResult matchForLikeLoop(Value iv, OpFoldResult &lb, OpFoldResult &ub,
+                               OpFoldResult &step);
+
+/// Populate the given constraint set with induction variable constraints of a
+/// "for" loop with the given range and step.
+LogicalResult addLoopRangeConstraints(affine::FlatAffineValueConstraints &cstr,
+                                      Value iv, OpFoldResult lb,
+                                      OpFoldResult ub, OpFoldResult step);
+
+/// Try to canonicalize the given affine.min/max operation in the context of
+/// for `loops` with a known range.
+///
+/// `loopMatcher` is used to retrieve loop bounds and the step size for a given
+/// iteration variable.
+///
+/// Note: `loopMatcher` allows this function to be used with any "for loop"-like
+/// operation (scf.for, scf.parallel and even ops defined in other dialects).
+LogicalResult canonicalizeMinMaxOpInLoop(RewriterBase &rewriter, Operation *op,
+                                         LoopMatcherFn loopMatcher);
+
+/// Try to simplify the given affine.min/max operation `op` after loop peeling.
+/// This function can simplify min/max operations such as (ub is the previous
+/// upper bound of the unpeeled loop):
+/// ```
+/// #map = affine_map<(d0)[s0, s1] -> (s0, -d0 + s1)>
+/// %r = affine.min #map(%iv)[%step, %ub]
+/// ```
+/// and rewrites them into (in the case the peeled loop):
+/// ```
+/// %r = %step
+/// ```
+/// min/max operations inside the partial iteration are rewritten in a similar
+/// way.
+LogicalResult rewritePeeledMinMaxOp(RewriterBase &rewriter, Operation *op,
+                                    Value iv, Value ub, Value step,
+                                    bool insideLoop);
+
+} // namespace scf
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SCF/Utils/Utils.h

@@ -0,0 +1,167 @@
+//===- Utils.h - SCF dialect utilities --------------------------*- 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 header file defines prototypes for various SCF utilities.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SCF_UTILS_UTILS_H_
+#define MLIR_DIALECT_SCF_UTILS_UTILS_H_
+
+#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Support/LLVM.h"
+#include "mlir/Support/LogicalResult.h"
+#include "llvm/ADT/STLExtras.h"
+#include <optional>
+
+namespace mlir {
+class Location;
+class Operation;
+class OpBuilder;
+class Region;
+class RewriterBase;
+class ValueRange;
+class Value;
+
+namespace func {
+class CallOp;
+class FuncOp;
+} // namespace func
+
+/// Update a perfectly nested loop nest to yield new values from the innermost
+/// loop and propagating it up through the loop nest. This function
+/// - Expects `loopNest` to be a perfectly nested loop with outer most loop
+///   first and innermost loop last.
+/// - `newIterOperands` are the initialization values to be used for the
+///    outermost loop
+/// - `newYielValueFn` is the callback that generates the new values to be
+///   yielded from within the innermost loop.
+/// - The original loops are not erased,  but are left in a "no-op" state where
+///   the body of the loop just yields the basic block arguments that correspond
+///   to the initialization values of a loop. The original loops are dead after
+///   this method.
+/// - If `replaceIterOperandsUsesInLoop` is true, all uses of the
+///   `newIterOperands` within the generated new loop are replaced with the
+///   corresponding `BlockArgument` in the loop body.
+SmallVector<scf::ForOp> replaceLoopNestWithNewYields(
+    RewriterBase &rewriter, MutableArrayRef<scf::ForOp> loopNest,
+    ValueRange newIterOperands, const NewYieldValuesFn &newYieldValuesFn,
+    bool replaceIterOperandsUsesInLoop = true);
+
+/// Outline a region with a single block into a new FuncOp.
+/// Assumes the FuncOp result types is the type of the yielded operands of the
+/// single block. This constraint makes it easy to determine the result.
+/// This method also clones the `arith::ConstantIndexOp` at the start of
+/// `outlinedFuncBody` to alloc simple canonicalizations.
+/// Creates a new FuncOp and thus cannot be used in a FuncOp pass.
+/// The client is responsible for providing a unique `funcName` that will not
+/// collide with another FuncOp name.  If `callOp` is provided, it will be set
+/// to point to the operation that calls the outlined function.
+// TODO: support more than single-block regions.
+// TODO: more flexible constant handling.
+FailureOr<func::FuncOp>
+outlineSingleBlockRegion(RewriterBase &rewriter, Location loc, Region &region,
+                         StringRef funcName, func::CallOp *callOp = nullptr);
+
+/// Outline the then and/or else regions of `ifOp` as follows:
+///  - if `thenFn` is not null, `thenFnName` must be specified and the `then`
+///    region is inlined into a new FuncOp that is captured by the pointer.
+///  - if `elseFn` is not null, `elseFnName` must be specified and the `else`
+///    region is inlined into a new FuncOp that is captured by the pointer.
+/// Creates new FuncOps and thus cannot be used in a FuncOp pass.
+/// The client is responsible for providing a unique `thenFnName`/`elseFnName`
+/// that will not collide with another FuncOp name.
+LogicalResult outlineIfOp(RewriterBase &b, scf::IfOp ifOp, func::FuncOp *thenFn,
+                          StringRef thenFnName, func::FuncOp *elseFn,
+                          StringRef elseFnName);
+
+/// Get a list of innermost parallel loops contained in `rootOp`. Innermost
+/// parallel loops are those that do not contain further parallel loops
+/// themselves.
+bool getInnermostParallelLoops(Operation *rootOp,
+                               SmallVectorImpl<scf::ParallelOp> &result);
+
+/// Return the min/max expressions for `value` if it is an induction variable
+/// from scf.for or scf.parallel loop.
+/// if `loopFilter` is passed, the filter determines which loop to consider.
+/// Other induction variables are ignored.
+std::optional<std::pair<AffineExpr, AffineExpr>>
+getSCFMinMaxExpr(Value value, SmallVectorImpl<Value> &dims,
+                 SmallVectorImpl<Value> &symbols,
+                 llvm::function_ref<bool(Operation *)> loopFilter = nullptr);
+
+/// Replace a perfect nest of "for" loops with a single linearized loop. Assumes
+/// `loops` contains a list of perfectly nested loops with bounds and steps
+/// independent of any loop induction variable involved in the nest.
+LogicalResult coalesceLoops(MutableArrayRef<scf::ForOp> loops);
+
+/// Take the ParallelLoop and for each set of dimension indices, combine them
+/// into a single dimension. combinedDimensions must contain each index into
+/// loops exactly once.
+void collapseParallelLoops(scf::ParallelOp loops,
+                           ArrayRef<std::vector<unsigned>> combinedDimensions);
+
+/// Unrolls this for operation by the specified unroll factor. Returns failure
+/// if the loop cannot be unrolled either due to restrictions or due to invalid
+/// unroll factors. Requires positive loop bounds and step. If specified,
+/// annotates the Ops in each unrolled iteration by applying `annotateFn`.
+LogicalResult loopUnrollByFactor(
+    scf::ForOp forOp, uint64_t unrollFactor,
+    function_ref<void(unsigned, Operation *, OpBuilder)> annotateFn = nullptr);
+
+/// Tile a nest of standard for loops rooted at `rootForOp` by finding such
+/// parametric tile sizes that the outer loops have a fixed number of iterations
+/// as defined in `sizes`.
+using Loops = SmallVector<scf::ForOp, 8>;
+using TileLoops = std::pair<Loops, Loops>;
+TileLoops extractFixedOuterLoops(scf::ForOp rootFOrOp, ArrayRef<int64_t> sizes);
+
+/// Performs tiling fo imperfectly nested loops (with interchange) by
+/// strip-mining the `forOps` by `sizes` and sinking them, in their order of
+/// occurrence in `forOps`, under each of the `targets`.
+/// Returns the new AffineForOps, one per each of (`forOps`, `targets`) pair,
+/// nested immediately under each of `targets`.
+SmallVector<Loops, 8> tile(ArrayRef<scf::ForOp> forOps, ArrayRef<Value> sizes,
+                           ArrayRef<scf::ForOp> targets);
+
+/// Performs tiling (with interchange) by strip-mining the `forOps` by `sizes`
+/// and sinking them, in their order of occurrence in `forOps`, under `target`.
+/// Returns the new AffineForOps, one per `forOps`, nested immediately under
+/// `target`.
+Loops tile(ArrayRef<scf::ForOp> forOps, ArrayRef<Value> sizes,
+           scf::ForOp target);
+
+/// Tile a nest of scf::ForOp loops rooted at `rootForOp` with the given
+/// (parametric) sizes. Sizes are expected to be strictly positive values at
+/// runtime.  If more sizes than loops are provided, discard the trailing values
+/// in sizes.  Assumes the loop nest is permutable.
+/// Returns the newly created intra-tile loops.
+Loops tilePerfectlyNested(scf::ForOp rootForOp, ArrayRef<Value> sizes);
+
+/// Get perfectly nested sequence of loops starting at root of loop nest
+/// (the first op being another AffineFor, and the second op - a terminator).
+/// A loop is perfectly nested iff: the first op in the loop's body is another
+/// AffineForOp, and the second op is a terminator).
+void getPerfectlyNestedLoops(SmallVectorImpl<scf::ForOp> &nestedLoops,
+                             scf::ForOp root);
+
+/// Given two scf.forall loops, `target` and `source`, fuses `target` into
+/// `source`. Assumes that the given loops are siblings and are independent of
+/// each other.
+///
+/// This function does not perform any legality checks and simply fuses the
+/// loops. The caller is responsible for ensuring that the loops are legal to
+/// fuse.
+scf::ForallOp fuseIndependentSiblingForallLoops(scf::ForallOp target,
+                                                scf::ForallOp source,
+                                                RewriterBase &rewriter);
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SCF_UTILS_UTILS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/Analysis/ShapeMappingAnalysis.h

@@ -0,0 +1,60 @@
+//===- ShapeMappingAnalysis.h - Preserve shape Info  ------------*- 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_SHAPE_ANALYSIS_SHAPEMAPPINGANALYSIS_H_
+#define MLIR_DIALECT_SHAPE_ANALYSIS_SHAPEMAPPINGANALYSIS_H_
+
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/Value.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace mlir {
+
+namespace shape {
+
+/// ShapeMappingValue works as the value of ShapeMappingAnalysis table, where
+/// `funcSymbol` is the symbol of mapping function, and `inputs` are the actual
+/// parameters for the function.
+struct ShapeMappingValue {
+  ShapeMappingValue() = default;
+  ShapeMappingValue(FlatSymbolRefAttr symbol, llvm::SmallVector<Value> &&inps)
+      : funcSymbol(symbol), inputs(inps) {}
+
+  FlatSymbolRefAttr funcSymbol;
+  llvm::SmallVector<Value> inputs;
+};
+
+/// ShapeMappingAnalysis is used together with OutlineShapeComputationPass to
+/// preserve Value and corresponding shape function / arguments mapping
+/// information
+struct ShapeMappingAnalysis {
+  ShapeMappingAnalysis(Operation *op) : operation(op) { (void)operation; }
+
+  /// Dumps the shape mapping information to the given stream.
+  void print(raw_ostream &os) const {
+    os << "// ---- Shape Mapping Information -----\n";
+    for (const auto &it : shapeMapping) {
+      const ShapeMappingValue &mappingValue = it.second;
+      os << "// Shape for " << it.first << " :: " << mappingValue.funcSymbol;
+      llvm::interleaveComma(mappingValue.inputs, os << "(");
+      os << ")\n";
+    }
+  }
+
+  llvm::DenseMap<Value, ShapeMappingValue> shapeMapping;
+
+private:
+  Operation *operation;
+};
+
+} // namespace shape
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SHAPE_ANALYSIS_SHAPEMAPPINGANALYSIS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/IR/Shape.h

@@ -0,0 +1,56 @@
+//===- Shape.h - MLIR Shape dialect -----------------------------*- 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 shape dialect that is used to describe and solve shape
+// relations of MLIR operations using ShapedType.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SHAPE_IR_SHAPE_H
+#define MLIR_DIALECT_SHAPE_IR_SHAPE_H
+
+#include "mlir/Bytecode/BytecodeOpInterface.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
+#include "mlir/Interfaces/CastInterfaces.h"
+#include "mlir/Interfaces/ControlFlowInterfaces.h"
+#include "mlir/Interfaces/FunctionInterfaces.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/Shape/IR/ShapeOpsTypes.h.inc"
+
+namespace mlir {
+class PatternRewriter;
+
+namespace shape {
+
+/// Alias type for extent tensors.
+RankedTensorType getExtentTensorType(MLIRContext *ctx,
+                                     int64_t rank = ShapedType::kDynamic);
+
+// Check if a type is an extent tensor, e.g., tensor<?xindex>.
+bool isExtentTensorType(Type);
+
+// Given an input shape Value, try to obtain the shape's values.
+LogicalResult getShapeVec(Value input, SmallVectorImpl<int64_t> &shapeValues);
+
+} // namespace shape
+} // namespace mlir
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/Shape/IR/ShapeOps.h.inc"
+
+#include "mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc"
+
+#endif // MLIR_DIALECT_SHAPE_IR_SHAPE_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/IR/ShapeCanonicalization.inc

@@ -0,0 +1,384 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Rewriters                                                                  *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: ShapeCanonicalization.td                                             *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:22
+*/
+struct AssumingAllOneOp : public ::mlir::RewritePattern {
+  AssumingAllOneOp(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("shape.assuming_all", 1, context, {}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::Operation::operand_range args(op0->getOperands());
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::shape::AssumingAllOp>(op0); (void)castedOp0;
+    args = castedOp0.getODSOperands(0);
+    if (!((
+      args.size() == 1
+    ))){
+      return rewriter.notifyMatchFailure(op0, [&](::mlir::Diagnostic &diag) {
+        diag << "entities 'args' failed to satisfy constraint: ''";
+      });
+    }
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ args }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:26
+*/
+struct CstrBroadcastableEqOps : public ::mlir::RewritePattern {
+  CstrBroadcastableEqOps(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("shape.cstr_broadcastable", 1, context, {"shape.const_witness"}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::Operation::operand_range shapes(op0->getOperands());
+    ::mlir::shape::CstrBroadcastableOp op;
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::shape::CstrBroadcastableOp>(op0); (void)castedOp0;
+    op = castedOp0;
+    shapes = castedOp0.getODSOperands(0);
+    if (!((
+      llvm::all_equal(shapes)
+    ))){
+      return rewriter.notifyMatchFailure(op0, [&](::mlir::Diagnostic &diag) {
+        diag << "entities 'shapes' failed to satisfy constraint: ''";
+      });
+    }
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+    ::mlir::shape::ConstWitnessOp tblgen_ConstWitnessOp_0;
+    {
+      ::llvm::SmallVector<::mlir::Value, 4> tblgen_values; (void)tblgen_values;
+      ::llvm::SmallVector<::mlir::NamedAttribute, 4> tblgen_attrs; (void)tblgen_attrs;
+      if (auto tmpAttr = rewriter.getBoolAttr(true)) {
+        tblgen_attrs.emplace_back(rewriter.getStringAttr("passing"), tmpAttr);
+      }
+      ::llvm::SmallVector<::mlir::Type, 4> tblgen_types; (void)tblgen_types;
+      for (auto v: castedOp0.getODSResults(0)) {
+        tblgen_types.push_back(v.getType());
+      }
+      tblgen_ConstWitnessOp_0 = rewriter.create<::mlir::shape::ConstWitnessOp>(odsLoc, tblgen_types, tblgen_values, tblgen_attrs);
+    }
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ tblgen_ConstWitnessOp_0.getODSResults(0) }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:30
+*/
+struct CstrEqEqOps : public ::mlir::RewritePattern {
+  CstrEqEqOps(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("shape.cstr_eq", 1, context, {"shape.const_witness"}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::Operation::operand_range shapes(op0->getOperands());
+    ::mlir::shape::CstrEqOp op;
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::shape::CstrEqOp>(op0); (void)castedOp0;
+    op = castedOp0;
+    shapes = castedOp0.getODSOperands(0);
+    if (!((
+      llvm::all_equal(shapes)
+    ))){
+      return rewriter.notifyMatchFailure(op0, [&](::mlir::Diagnostic &diag) {
+        diag << "entities 'shapes' failed to satisfy constraint: ''";
+      });
+    }
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+    ::mlir::shape::ConstWitnessOp tblgen_ConstWitnessOp_0;
+    {
+      ::llvm::SmallVector<::mlir::Value, 4> tblgen_values; (void)tblgen_values;
+      ::llvm::SmallVector<::mlir::NamedAttribute, 4> tblgen_attrs; (void)tblgen_attrs;
+      if (auto tmpAttr = rewriter.getBoolAttr(true)) {
+        tblgen_attrs.emplace_back(rewriter.getStringAttr("passing"), tmpAttr);
+      }
+      ::llvm::SmallVector<::mlir::Type, 4> tblgen_types; (void)tblgen_types;
+      for (auto v: castedOp0.getODSResults(0)) {
+        tblgen_types.push_back(v.getType());
+      }
+      tblgen_ConstWitnessOp_0 = rewriter.create<::mlir::shape::ConstWitnessOp>(odsLoc, tblgen_types, tblgen_values, tblgen_attrs);
+    }
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ tblgen_ConstWitnessOp_0.getODSResults(0) }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:50
+*/
+struct ExtractFromShapeOfExtentTensor : public ::mlir::RewritePattern {
+  ExtractFromShapeOfExtentTensor(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("tensor.extract", 2, context, {"tensor.dim"}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::Operation::operand_range indices(op0->getOperands());
+    ::mlir::Operation::operand_range arg(op0->getOperands());
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::tensor::ExtractOp>(op0); (void)castedOp0;
+    {
+      auto *op1 = (*castedOp0.getODSOperands(0).begin()).getDefiningOp();
+      if (!(op1)){
+        return rewriter.notifyMatchFailure(castedOp0, [&](::mlir::Diagnostic &diag) {
+          diag << "There's no operation that defines operand 0 of castedOp0";
+        });
+      }
+      auto castedOp1 = ::llvm::dyn_cast<::mlir::shape::ShapeOfOp>(op1); (void)castedOp1;
+      if (!(castedOp1)){
+        return rewriter.notifyMatchFailure(op1, [&](::mlir::Diagnostic &diag) {
+          diag << "castedOp1 is not ::mlir::shape::ShapeOfOp type";
+        });
+      }
+      arg = castedOp1.getODSOperands(0);
+      tblgen_ops.push_back(op1);
+    }
+    indices = castedOp0.getODSOperands(1);
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc(), tblgen_ops[1]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+    auto nativeVar_0 = indices.front(); (void)nativeVar_0;
+    ::mlir::tensor::DimOp tblgen_DimOp_1;
+    {
+      ::llvm::SmallVector<::mlir::Value, 4> tblgen_values; (void)tblgen_values;
+      ::llvm::SmallVector<::mlir::NamedAttribute, 4> tblgen_attrs; (void)tblgen_attrs;
+      tblgen_values.push_back((*arg.begin()));
+      tblgen_values.push_back(nativeVar_0);
+      ::llvm::SmallVector<::mlir::Type, 4> tblgen_types; (void)tblgen_types;
+      for (auto v: castedOp0.getODSResults(0)) {
+        tblgen_types.push_back(v.getType());
+      }
+      tblgen_DimOp_1 = rewriter.create<::mlir::tensor::DimOp>(odsLoc, tblgen_types, tblgen_values, tblgen_attrs);
+    }
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ tblgen_DimOp_1.getODSResults(0) }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:34
+*/
+struct IndexToSizeToIndexCanonicalization : public ::mlir::RewritePattern {
+  IndexToSizeToIndexCanonicalization(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("shape.size_to_index", 2, context, {}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::Operation::operand_range arg(op0->getOperands());
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::shape::SizeToIndexOp>(op0); (void)castedOp0;
+    {
+      auto *op1 = (*castedOp0.getODSOperands(0).begin()).getDefiningOp();
+      if (!(op1)){
+        return rewriter.notifyMatchFailure(castedOp0, [&](::mlir::Diagnostic &diag) {
+          diag << "There's no operation that defines operand 0 of castedOp0";
+        });
+      }
+      auto castedOp1 = ::llvm::dyn_cast<::mlir::shape::IndexToSizeOp>(op1); (void)castedOp1;
+      if (!(castedOp1)){
+        return rewriter.notifyMatchFailure(op1, [&](::mlir::Diagnostic &diag) {
+          diag << "castedOp1 is not ::mlir::shape::IndexToSizeOp type";
+        });
+      }
+      arg = castedOp1.getODSOperands(0);
+      tblgen_ops.push_back(op1);
+    }
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc(), tblgen_ops[1]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ arg }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:38
+*/
+struct SizeToIndexToSizeCanonicalization : public ::mlir::RewritePattern {
+  SizeToIndexToSizeCanonicalization(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("shape.index_to_size", 2, context, {}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::Operation::operand_range arg(op0->getOperands());
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::shape::IndexToSizeOp>(op0); (void)castedOp0;
+    {
+      auto *op1 = (*castedOp0.getODSOperands(0).begin()).getDefiningOp();
+      if (!(op1)){
+        return rewriter.notifyMatchFailure(castedOp0, [&](::mlir::Diagnostic &diag) {
+          diag << "There's no operation that defines operand 0 of castedOp0";
+        });
+      }
+      auto castedOp1 = ::llvm::dyn_cast<::mlir::shape::SizeToIndexOp>(op1); (void)castedOp1;
+      if (!(castedOp1)){
+        return rewriter.notifyMatchFailure(op1, [&](::mlir::Diagnostic &diag) {
+          diag << "castedOp1 is not ::mlir::shape::SizeToIndexOp type";
+        });
+      }
+      arg = castedOp1.getODSOperands(0);
+      tblgen_ops.push_back(op1);
+    }
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc(), tblgen_ops[1]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ arg }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+/* Generated from:
+    external/llvm-project/mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td:44
+*/
+struct TensorCastConstShape : public ::mlir::RewritePattern {
+  TensorCastConstShape(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("tensor.cast", 2, context, {"shape.const_shape"}) {}
+  ::mlir::LogicalResult matchAndRewrite(::mlir::Operation *op0,
+      ::mlir::PatternRewriter &rewriter) const override {
+    // Variables for capturing values and attributes used while creating ops
+    ::mlir::DenseIntElementsAttr arg;
+    ::mlir::tensor::CastOp res;
+    ::llvm::SmallVector<::mlir::Operation *, 4> tblgen_ops;
+
+    // Match
+    tblgen_ops.push_back(op0);
+    auto castedOp0 = ::llvm::dyn_cast<::mlir::tensor::CastOp>(op0); (void)castedOp0;
+    res = castedOp0;
+    {
+      auto *op1 = (*castedOp0.getODSOperands(0).begin()).getDefiningOp();
+      if (!(op1)){
+        return rewriter.notifyMatchFailure(castedOp0, [&](::mlir::Diagnostic &diag) {
+          diag << "There's no operation that defines operand 0 of castedOp0";
+        });
+      }
+      auto castedOp1 = ::llvm::dyn_cast<::mlir::shape::ConstShapeOp>(op1); (void)castedOp1;
+      if (!(castedOp1)){
+        return rewriter.notifyMatchFailure(op1, [&](::mlir::Diagnostic &diag) {
+          diag << "castedOp1 is not ::mlir::shape::ConstShapeOp type";
+        });
+      }
+      {
+        auto tblgen_attr = op1->getAttrOfType<::mlir::DenseIntElementsAttr>("shape");(void)tblgen_attr;
+        if (!(tblgen_attr)){
+          return rewriter.notifyMatchFailure(op1, [&](::mlir::Diagnostic &diag) {
+            diag << "expected op 'shape.const_shape' to have attribute 'shape' of type '::mlir::DenseIntElementsAttr'";
+          });
+        }
+        arg = tblgen_attr;
+      }
+      tblgen_ops.push_back(op1);
+    }
+    if (!((
+      ::llvm::dyn_cast<ShapedType>((*res.getODSResults(0).begin()).getType()).hasStaticShape()
+    ))){
+      return rewriter.notifyMatchFailure(op0, [&](::mlir::Diagnostic &diag) {
+        diag << "entities 'res' failed to satisfy constraint: ''";
+      });
+    }
+
+    // Rewrite
+    auto odsLoc = rewriter.getFusedLoc({tblgen_ops[0]->getLoc(), tblgen_ops[1]->getLoc()}); (void)odsLoc;
+    ::llvm::SmallVector<::mlir::Value, 4> tblgen_repl_values;
+    ::mlir::shape::ConstShapeOp tblgen_ConstShapeOp_0;
+    {
+      ::llvm::SmallVector<::mlir::Value, 4> tblgen_values; (void)tblgen_values;
+      ::llvm::SmallVector<::mlir::NamedAttribute, 4> tblgen_attrs; (void)tblgen_attrs;
+      if (auto tmpAttr = arg) {
+        tblgen_attrs.emplace_back(rewriter.getStringAttr("shape"), tmpAttr);
+      }
+      ::llvm::SmallVector<::mlir::Type, 4> tblgen_types; (void)tblgen_types;
+      for (auto v: castedOp0.getODSResults(0)) {
+        tblgen_types.push_back(v.getType());
+      }
+      tblgen_ConstShapeOp_0 = rewriter.create<::mlir::shape::ConstShapeOp>(odsLoc, tblgen_types, tblgen_values, tblgen_attrs);
+    }
+
+    for (auto v: ::llvm::SmallVector<::mlir::Value, 4>{ tblgen_ConstShapeOp_0.getODSResults(0) }) {
+      tblgen_repl_values.push_back(v);
+    }
+
+    rewriter.replaceOp(op0, tblgen_repl_values);
+    return ::mlir::success();
+  };
+};
+
+void LLVM_ATTRIBUTE_UNUSED populateWithGenerated(::mlir::RewritePatternSet &patterns) {
+  patterns.add<AssumingAllOneOp>(patterns.getContext());
+  patterns.add<CstrBroadcastableEqOps>(patterns.getContext());
+  patterns.add<CstrEqEqOps>(patterns.getContext());
+  patterns.add<ExtractFromShapeOfExtentTensor>(patterns.getContext());
+  patterns.add<IndexToSizeToIndexCanonicalization>(patterns.getContext());
+  patterns.add<SizeToIndexToSizeCanonicalization>(patterns.getContext());
+  patterns.add<TensorCastConstShape>(patterns.getContext());
+}

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/IR/ShapeOpsDialect.cpp.inc

@@ -0,0 +1,27 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Dialect Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: ShapeOps.td                                                          *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::shape::ShapeDialect)
+namespace mlir {
+namespace shape {
+
+ShapeDialect::ShapeDialect(::mlir::MLIRContext *context)
+    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<ShapeDialect>()) {
+  
+    getContext()->loadDialect<arith::ArithDialect>();
+
+    getContext()->loadDialect<tensor::TensorDialect>();
+
+  initialize();
+}
+
+ShapeDialect::~ShapeDialect() = default;
+
+} // namespace shape
+} // namespace mlir

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc

@@ -0,0 +1,45 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Dialect Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: ShapeOps.td                                                          *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+namespace mlir {
+namespace shape {
+
+class ShapeDialect : public ::mlir::Dialect {
+  explicit ShapeDialect(::mlir::MLIRContext *context);
+
+  void initialize();
+  friend class ::mlir::MLIRContext;
+public:
+  ~ShapeDialect() override;
+  static constexpr ::llvm::StringLiteral getDialectNamespace() {
+    return ::llvm::StringLiteral("shape");
+  }
+
+  /// Parse a type registered to this dialect.
+  ::mlir::Type parseType(::mlir::DialectAsmParser &parser) const override;
+
+  /// Print a type registered to this dialect.
+  void printType(::mlir::Type type,
+                 ::mlir::DialectAsmPrinter &os) const override;
+
+  /// Materialize a single constant operation from a given attribute value with
+  /// the desired resultant type.
+  ::mlir::Operation *materializeConstant(::mlir::OpBuilder &builder,
+                                         ::mlir::Attribute value,
+                                         ::mlir::Type type,
+                                         ::mlir::Location loc) override;
+
+    /// Provides a hook for verifying dialect attributes attached to the given
+    /// op.
+    ::mlir::LogicalResult verifyOperationAttribute(
+        ::mlir::Operation *op, ::mlir::NamedAttribute attribute) override;
+};
+} // namespace shape
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::shape::ShapeDialect)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/IR/ShapeOpsTypes.cpp.inc

@@ -0,0 +1,113 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* TypeDef Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_TYPEDEF_LIST
+#undef GET_TYPEDEF_LIST
+
+::mlir::shape::ShapeType,
+::mlir::shape::SizeType,
+::mlir::shape::ValueShapeType,
+::mlir::shape::WitnessType
+
+#endif  // GET_TYPEDEF_LIST
+
+#ifdef GET_TYPEDEF_CLASSES
+#undef GET_TYPEDEF_CLASSES
+
+static ::mlir::OptionalParseResult generatedTypeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type &value) {
+  return ::mlir::AsmParser::KeywordSwitch<::mlir::OptionalParseResult>(parser)
+    .Case(::mlir::shape::ShapeType::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::shape::ShapeType::get(parser.getContext());
+      return ::mlir::success(!!value);
+    })
+    .Case(::mlir::shape::SizeType::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::shape::SizeType::get(parser.getContext());
+      return ::mlir::success(!!value);
+    })
+    .Case(::mlir::shape::ValueShapeType::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::shape::ValueShapeType::get(parser.getContext());
+      return ::mlir::success(!!value);
+    })
+    .Case(::mlir::shape::WitnessType::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::shape::WitnessType::get(parser.getContext());
+      return ::mlir::success(!!value);
+    })
+    .Default([&](llvm::StringRef keyword, llvm::SMLoc) {
+      *mnemonic = keyword;
+      return std::nullopt;
+    });
+}
+
+static ::mlir::LogicalResult generatedTypePrinter(::mlir::Type def, ::mlir::AsmPrinter &printer) {
+  return ::llvm::TypeSwitch<::mlir::Type, ::mlir::LogicalResult>(def)    .Case<::mlir::shape::ShapeType>([&](auto t) {
+      printer << ::mlir::shape::ShapeType::getMnemonic();
+      return ::mlir::success();
+    })
+    .Case<::mlir::shape::SizeType>([&](auto t) {
+      printer << ::mlir::shape::SizeType::getMnemonic();
+      return ::mlir::success();
+    })
+    .Case<::mlir::shape::ValueShapeType>([&](auto t) {
+      printer << ::mlir::shape::ValueShapeType::getMnemonic();
+      return ::mlir::success();
+    })
+    .Case<::mlir::shape::WitnessType>([&](auto t) {
+      printer << ::mlir::shape::WitnessType::getMnemonic();
+      return ::mlir::success();
+    })
+    .Default([](auto) { return ::mlir::failure(); });
+}
+
+namespace mlir {
+namespace shape {
+} // namespace shape
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::shape::ShapeType)
+namespace mlir {
+namespace shape {
+} // namespace shape
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::shape::SizeType)
+namespace mlir {
+namespace shape {
+} // namespace shape
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::shape::ValueShapeType)
+namespace mlir {
+namespace shape {
+} // namespace shape
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::shape::WitnessType)
+namespace mlir {
+namespace shape {
+
+/// Parse a type registered to this dialect.
+::mlir::Type ShapeDialect::parseType(::mlir::DialectAsmParser &parser) const {
+  ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  ::llvm::StringRef mnemonic;
+  ::mlir::Type genType;
+  auto parseResult = generatedTypeParser(parser, &mnemonic, genType);
+  if (parseResult.has_value())
+    return genType;
+  
+  parser.emitError(typeLoc) << "unknown  type `"
+      << mnemonic << "` in dialect `" << getNamespace() << "`";
+  return {};
+}
+/// Print a type registered to this dialect.
+void ShapeDialect::printType(::mlir::Type type,
+                    ::mlir::DialectAsmPrinter &printer) const {
+  if (::mlir::succeeded(generatedTypePrinter(type, printer)))
+    return;
+  
+}
+} // namespace shape
+} // namespace mlir
+
+#endif  // GET_TYPEDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/IR/ShapeOpsTypes.h.inc

@@ -0,0 +1,63 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* TypeDef Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_TYPEDEF_CLASSES
+#undef GET_TYPEDEF_CLASSES
+
+
+namespace mlir {
+class AsmParser;
+class AsmPrinter;
+} // namespace mlir
+namespace mlir {
+namespace shape {
+class ShapeType;
+class SizeType;
+class ValueShapeType;
+class WitnessType;
+class ShapeType : public ::mlir::Type::TypeBase<ShapeType, ::mlir::Type, ::mlir::TypeStorage> {
+public:
+  using Base::Base;
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"shape"};
+  }
+
+};
+class SizeType : public ::mlir::Type::TypeBase<SizeType, ::mlir::Type, ::mlir::TypeStorage> {
+public:
+  using Base::Base;
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"size"};
+  }
+
+};
+class ValueShapeType : public ::mlir::Type::TypeBase<ValueShapeType, ::mlir::Type, ::mlir::TypeStorage> {
+public:
+  using Base::Base;
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"value_shape"};
+  }
+
+};
+class WitnessType : public ::mlir::Type::TypeBase<WitnessType, ::mlir::Type, ::mlir::TypeStorage> {
+public:
+  using Base::Base;
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"witness"};
+  }
+
+};
+} // namespace shape
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::shape::ShapeType)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::shape::SizeType)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::shape::ValueShapeType)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::shape::WitnessType)
+
+#endif  // GET_TYPEDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.h

@@ -0,0 +1,20 @@
+//===- BufferizableOpInterfaceImpl.h - Impl. of BufferizableOpInterface ---===//
+//
+// 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_SHAPE_BUFFERIZABLEOPINTERFACEIMPL_H
+#define MLIR_DIALECT_SHAPE_BUFFERIZABLEOPINTERFACEIMPL_H
+
+namespace mlir {
+class DialectRegistry;
+
+namespace shape {
+void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
+} // namespace shape
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SHAPE_BUFFERIZABLEOPINTERFACEIMPL_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

@@ -0,0 +1,71 @@
+//===- Passes.h - Pass Entrypoints ------------------------------*- 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 header file defines prototypes that expose pass constructors in the
+// shape transformation library.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_
+#define MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_
+
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+class ConversionTarget;
+class ModuleOp;
+class TypeConverter;
+namespace func {
+class FuncOp;
+} // namespace func
+} // namespace mlir
+
+namespace mlir {
+
+#define GEN_PASS_DECL
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+
+/// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
+/// dialect to be convertible to Arith. For example, `shape.num_elements` get
+/// transformed to `shape.reduce`, which can be lowered to SCF and Arith.
+std::unique_ptr<Pass> createShapeToShapeLowering();
+
+/// Collects a set of patterns to rewrite ops within the Shape dialect.
+void populateShapeRewritePatterns(RewritePatternSet &patterns);
+
+// Collects a set of patterns to replace all constraints with passing witnesses.
+// This is intended to then allow all ShapeConstraint related ops and data to
+// have no effects and allow them to be freely removed such as through
+// canonicalization and dead code elimination.
+//
+// After this pass, no cstr_ operations exist.
+void populateRemoveShapeConstraintsPatterns(RewritePatternSet &patterns);
+std::unique_ptr<OperationPass<func::FuncOp>> createRemoveShapeConstraintsPass();
+
+// Bufferizes shape dialect ops.
+//
+// Note that most shape dialect ops must be converted to std before
+// bufferization happens, as they are intended to be bufferized at the std
+// level.
+std::unique_ptr<OperationPass<func::FuncOp>> createShapeBufferizePass();
+
+/// Outline the shape computation part by adding shape.func and populate
+/// conrresponding mapping infomation into ShapeMappingAnalysis.
+std::unique_ptr<OperationPass<ModuleOp>> createOutlineShapeComputationPass();
+
+//===----------------------------------------------------------------------===//
+// Registration
+//===----------------------------------------------------------------------===//
+
+/// Generate the code for registering passes.
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/Shape/Transforms/Passes.h.inc

@@ -0,0 +1,520 @@
+/* Autogenerated by mlir-tblgen; don't manually edit */
+
+#ifdef GEN_PASS_DECL
+// Generate declarations for all passes.
+#define GEN_PASS_DECL_OUTLINESHAPECOMPUTATION
+#define GEN_PASS_DECL_REMOVESHAPECONSTRAINTS
+#define GEN_PASS_DECL_SHAPEBUFFERIZE
+#define GEN_PASS_DECL_SHAPETOSHAPELOWERING
+#undef GEN_PASS_DECL
+#endif // GEN_PASS_DECL
+
+//===----------------------------------------------------------------------===//
+// OutlineShapeComputation
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_OUTLINESHAPECOMPUTATION
+#undef GEN_PASS_DECL_OUTLINESHAPECOMPUTATION
+#endif // GEN_PASS_DECL_OUTLINESHAPECOMPUTATION
+#ifdef GEN_PASS_DEF_OUTLINESHAPECOMPUTATION
+namespace impl {
+
+template <typename DerivedT>
+class OutlineShapeComputationBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = OutlineShapeComputationBase;
+
+  OutlineShapeComputationBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  OutlineShapeComputationBase(const OutlineShapeComputationBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("outline-shape-computation");
+  }
+  ::llvm::StringRef getArgument() const override { return "outline-shape-computation"; }
+
+  ::llvm::StringRef getDescription() const override { return "Using shape.func to preserve shape computation"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("OutlineShapeComputation");
+  }
+  ::llvm::StringRef getName() const override { return "OutlineShapeComputation"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<shape::ShapeDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OutlineShapeComputationBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_OUTLINESHAPECOMPUTATION
+#endif // GEN_PASS_DEF_OUTLINESHAPECOMPUTATION
+
+//===----------------------------------------------------------------------===//
+// RemoveShapeConstraints
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_REMOVESHAPECONSTRAINTS
+#undef GEN_PASS_DECL_REMOVESHAPECONSTRAINTS
+#endif // GEN_PASS_DECL_REMOVESHAPECONSTRAINTS
+#ifdef GEN_PASS_DEF_REMOVESHAPECONSTRAINTS
+namespace impl {
+
+template <typename DerivedT>
+class RemoveShapeConstraintsBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = RemoveShapeConstraintsBase;
+
+  RemoveShapeConstraintsBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  RemoveShapeConstraintsBase(const RemoveShapeConstraintsBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("remove-shape-constraints");
+  }
+  ::llvm::StringRef getArgument() const override { return "remove-shape-constraints"; }
+
+  ::llvm::StringRef getDescription() const override { return "Replace all cstr_ ops with a true witness"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("RemoveShapeConstraints");
+  }
+  ::llvm::StringRef getName() const override { return "RemoveShapeConstraints"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RemoveShapeConstraintsBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_REMOVESHAPECONSTRAINTS
+#endif // GEN_PASS_DEF_REMOVESHAPECONSTRAINTS
+
+//===----------------------------------------------------------------------===//
+// ShapeBufferize
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SHAPEBUFFERIZE
+#undef GEN_PASS_DECL_SHAPEBUFFERIZE
+#endif // GEN_PASS_DECL_SHAPEBUFFERIZE
+#ifdef GEN_PASS_DEF_SHAPEBUFFERIZE
+namespace impl {
+
+template <typename DerivedT>
+class ShapeBufferizeBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = ShapeBufferizeBase;
+
+  ShapeBufferizeBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  ShapeBufferizeBase(const ShapeBufferizeBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("shape-bufferize");
+  }
+  ::llvm::StringRef getArgument() const override { return "shape-bufferize"; }
+
+  ::llvm::StringRef getDescription() const override { return "Bufferize the shape dialect."; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("ShapeBufferize");
+  }
+  ::llvm::StringRef getName() const override { return "ShapeBufferize"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeBufferizeBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SHAPEBUFFERIZE
+#endif // GEN_PASS_DEF_SHAPEBUFFERIZE
+
+//===----------------------------------------------------------------------===//
+// ShapeToShapeLowering
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SHAPETOSHAPELOWERING
+#undef GEN_PASS_DECL_SHAPETOSHAPELOWERING
+#endif // GEN_PASS_DECL_SHAPETOSHAPELOWERING
+#ifdef GEN_PASS_DEF_SHAPETOSHAPELOWERING
+namespace impl {
+
+template <typename DerivedT>
+class ShapeToShapeLoweringBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = ShapeToShapeLoweringBase;
+
+  ShapeToShapeLoweringBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  ShapeToShapeLoweringBase(const ShapeToShapeLoweringBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("shape-to-shape-lowering");
+  }
+  ::llvm::StringRef getArgument() const override { return "shape-to-shape-lowering"; }
+
+  ::llvm::StringRef getDescription() const override { return "Legalize Shape dialect to be convertible to Arith"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("ShapeToShapeLowering");
+  }
+  ::llvm::StringRef getName() const override { return "ShapeToShapeLowering"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeToShapeLoweringBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SHAPETOSHAPELOWERING
+#endif // GEN_PASS_DEF_SHAPETOSHAPELOWERING
+#ifdef GEN_PASS_REGISTRATION
+
+//===----------------------------------------------------------------------===//
+// OutlineShapeComputation Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerOutlineShapeComputation() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createOutlineShapeComputationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerOutlineShapeComputationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createOutlineShapeComputationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// RemoveShapeConstraints Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerRemoveShapeConstraints() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createRemoveShapeConstraintsPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerRemoveShapeConstraintsPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createRemoveShapeConstraintsPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// ShapeBufferize Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerShapeBufferize() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createShapeBufferizePass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerShapeBufferizePass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createShapeBufferizePass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// ShapeToShapeLowering Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerShapeToShapeLowering() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createShapeToShapeLowering();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerShapeToShapeLoweringPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createShapeToShapeLowering();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// Shape Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerShapePasses() {
+  registerOutlineShapeComputation();
+  registerRemoveShapeConstraints();
+  registerShapeBufferize();
+  registerShapeToShapeLowering();
+}
+#undef GEN_PASS_REGISTRATION
+#endif // GEN_PASS_REGISTRATION
+// Deprecated. Please use the new per-pass macros.
+#ifdef GEN_PASS_CLASSES
+
+template <typename DerivedT>
+class OutlineShapeComputationBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = OutlineShapeComputationBase;
+
+  OutlineShapeComputationBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  OutlineShapeComputationBase(const OutlineShapeComputationBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("outline-shape-computation");
+  }
+  ::llvm::StringRef getArgument() const override { return "outline-shape-computation"; }
+
+  ::llvm::StringRef getDescription() const override { return "Using shape.func to preserve shape computation"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("OutlineShapeComputation");
+  }
+  ::llvm::StringRef getName() const override { return "OutlineShapeComputation"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<shape::ShapeDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OutlineShapeComputationBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class RemoveShapeConstraintsBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = RemoveShapeConstraintsBase;
+
+  RemoveShapeConstraintsBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  RemoveShapeConstraintsBase(const RemoveShapeConstraintsBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("remove-shape-constraints");
+  }
+  ::llvm::StringRef getArgument() const override { return "remove-shape-constraints"; }
+
+  ::llvm::StringRef getDescription() const override { return "Replace all cstr_ ops with a true witness"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("RemoveShapeConstraints");
+  }
+  ::llvm::StringRef getName() const override { return "RemoveShapeConstraints"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RemoveShapeConstraintsBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class ShapeBufferizeBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = ShapeBufferizeBase;
+
+  ShapeBufferizeBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  ShapeBufferizeBase(const ShapeBufferizeBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("shape-bufferize");
+  }
+  ::llvm::StringRef getArgument() const override { return "shape-bufferize"; }
+
+  ::llvm::StringRef getDescription() const override { return "Bufferize the shape dialect."; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("ShapeBufferize");
+  }
+  ::llvm::StringRef getName() const override { return "ShapeBufferize"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeBufferizeBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class ShapeToShapeLoweringBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = ShapeToShapeLoweringBase;
+
+  ShapeToShapeLoweringBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  ShapeToShapeLoweringBase(const ShapeToShapeLoweringBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("shape-to-shape-lowering");
+  }
+  ::llvm::StringRef getArgument() const override { return "shape-to-shape-lowering"; }
+
+  ::llvm::StringRef getDescription() const override { return "Legalize Shape dialect to be convertible to Arith"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("ShapeToShapeLowering");
+  }
+  ::llvm::StringRef getName() const override { return "ShapeToShapeLowering"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ShapeToShapeLoweringBase<DerivedT>)
+
+protected:
+};
+#undef GEN_PASS_CLASSES
+#endif // GEN_PASS_CLASSES

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/Enums.h

@@ -0,0 +1,451 @@
+//===- Enums.h - Enums for the SparseTensor dialect -------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Typedefs and enums shared between MLIR code for manipulating the
+// IR, and the lightweight runtime support library for sparse tensor
+// manipulations.  That is, all the enums are used to define the API
+// of the runtime library and hence are also needed when generating
+// calls into the runtime library.  Moveover, the `DimLevelType` enum
+// is also used as the internal IR encoding of dimension level types,
+// to avoid code duplication (e.g., for the predicates).
+//
+// This file also defines x-macros <https://en.wikipedia.org/wiki/X_Macro>
+// so that we can generate variations of the public functions for each
+// supported primary- and/or overhead-type.
+//
+// Because this file defines a library which is a dependency of the
+// runtime library itself, this file must not depend on any MLIR internals
+// (e.g., operators, attributes, ArrayRefs, etc) lest the runtime library
+// inherit those dependencies.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SPARSETENSOR_IR_ENUMS_H
+#define MLIR_DIALECT_SPARSETENSOR_IR_ENUMS_H
+
+// NOTE: Client code will need to include "mlir/ExecutionEngine/Float16bits.h"
+// if they want to use the `MLIR_SPARSETENSOR_FOREVERY_V` macro.
+
+#include <cinttypes>
+#include <complex>
+#include <optional>
+
+namespace mlir {
+namespace sparse_tensor {
+
+/// This type is used in the public API at all places where MLIR expects
+/// values with the built-in type "index".  For now, we simply assume that
+/// type is 64-bit, but targets with different "index" bitwidths should
+/// link with an alternatively built runtime support library.
+using index_type = uint64_t;
+
+/// Encoding of overhead types (both position overhead and coordinate
+/// overhead), for "overloading" @newSparseTensor.
+enum class OverheadType : uint32_t {
+  kIndex = 0,
+  kU64 = 1,
+  kU32 = 2,
+  kU16 = 3,
+  kU8 = 4
+};
+
+// This x-macro calls its argument on every overhead type which has
+// fixed-width.  It excludes `index_type` because that type is often
+// handled specially (e.g., by translating it into the architecture-dependent
+// equivalent fixed-width overhead type).
+#define MLIR_SPARSETENSOR_FOREVERY_FIXED_O(DO)                                 \
+  DO(64, uint64_t)                                                             \
+  DO(32, uint32_t)                                                             \
+  DO(16, uint16_t)                                                             \
+  DO(8, uint8_t)
+
+// This x-macro calls its argument on every overhead type, including
+// `index_type`.
+#define MLIR_SPARSETENSOR_FOREVERY_O(DO)                                       \
+  MLIR_SPARSETENSOR_FOREVERY_FIXED_O(DO)                                       \
+  DO(0, index_type)
+
+// These are not just shorthands but indicate the particular
+// implementation used (e.g., as opposed to C99's `complex double`,
+// or MLIR's `ComplexType`).
+using complex64 = std::complex<double>;
+using complex32 = std::complex<float>;
+
+/// Encoding of the elemental type, for "overloading" @newSparseTensor.
+enum class PrimaryType : uint32_t {
+  kF64 = 1,
+  kF32 = 2,
+  kF16 = 3,
+  kBF16 = 4,
+  kI64 = 5,
+  kI32 = 6,
+  kI16 = 7,
+  kI8 = 8,
+  kC64 = 9,
+  kC32 = 10
+};
+
+// This x-macro includes all `V` types.
+#define MLIR_SPARSETENSOR_FOREVERY_V(DO)                                       \
+  DO(F64, double)                                                              \
+  DO(F32, float)                                                               \
+  DO(F16, f16)                                                                 \
+  DO(BF16, bf16)                                                               \
+  DO(I64, int64_t)                                                             \
+  DO(I32, int32_t)                                                             \
+  DO(I16, int16_t)                                                             \
+  DO(I8, int8_t)                                                               \
+  DO(C64, complex64)                                                           \
+  DO(C32, complex32)
+
+// This x-macro includes all `V` types and supports variadic arguments.
+#define MLIR_SPARSETENSOR_FOREVERY_V_VAR(DO, ...)                              \
+  DO(F64, double, __VA_ARGS__)                                                 \
+  DO(F32, float, __VA_ARGS__)                                                  \
+  DO(F16, f16, __VA_ARGS__)                                                    \
+  DO(BF16, bf16, __VA_ARGS__)                                                  \
+  DO(I64, int64_t, __VA_ARGS__)                                                \
+  DO(I32, int32_t, __VA_ARGS__)                                                \
+  DO(I16, int16_t, __VA_ARGS__)                                                \
+  DO(I8, int8_t, __VA_ARGS__)                                                  \
+  DO(C64, complex64, __VA_ARGS__)                                              \
+  DO(C32, complex32, __VA_ARGS__)
+
+// This x-macro calls its argument on every pair of overhead and `V` types.
+#define MLIR_SPARSETENSOR_FOREVERY_V_O(DO)                                     \
+  MLIR_SPARSETENSOR_FOREVERY_V_VAR(DO, 64, uint64_t)                           \
+  MLIR_SPARSETENSOR_FOREVERY_V_VAR(DO, 32, uint32_t)                           \
+  MLIR_SPARSETENSOR_FOREVERY_V_VAR(DO, 16, uint16_t)                           \
+  MLIR_SPARSETENSOR_FOREVERY_V_VAR(DO, 8, uint8_t)                             \
+  MLIR_SPARSETENSOR_FOREVERY_V_VAR(DO, 0, index_type)
+
+constexpr bool isFloatingPrimaryType(PrimaryType valTy) {
+  return PrimaryType::kF64 <= valTy && valTy <= PrimaryType::kBF16;
+}
+
+constexpr bool isIntegralPrimaryType(PrimaryType valTy) {
+  return PrimaryType::kI64 <= valTy && valTy <= PrimaryType::kI8;
+}
+
+constexpr bool isRealPrimaryType(PrimaryType valTy) {
+  return PrimaryType::kF64 <= valTy && valTy <= PrimaryType::kI8;
+}
+
+constexpr bool isComplexPrimaryType(PrimaryType valTy) {
+  return PrimaryType::kC64 <= valTy && valTy <= PrimaryType::kC32;
+}
+
+/// The actions performed by @newSparseTensor.
+enum class Action : uint32_t {
+  kEmpty = 0,
+  // newSparseTensor no longer handles `kFromFile=1`, so we leave this
+  // number reserved to help catch any code that still needs updating.
+  kFromCOO = 2,
+  kSparseToSparse = 3,
+  kEmptyCOO = 4,
+  kToCOO = 5,
+  kToIterator = 6,
+  kPack = 7,
+};
+
+/// This enum defines all the sparse representations supportable by
+/// the SparseTensor dialect.  We use a lightweight encoding to encode
+/// both the "format" per se (dense, compressed, singleton) as well as
+/// the "properties" (ordered, unique).  The encoding is chosen for
+/// performance of the runtime library, and thus may change in future
+/// versions; consequently, client code should use the predicate functions
+/// defined below, rather than relying on knowledge about the particular
+/// binary encoding.
+///
+/// The `Undef` "format" is a special value used internally for cases
+/// where we need to store an undefined or indeterminate `DimLevelType`.
+/// It should not be used externally, since it does not indicate an
+/// actual/representable format.
+///
+// TODO: We should generalize TwoOutOfFour to N out of M and use property to
+// encode the value of N and M.
+// TODO: Update DimLevelType to use lower 8 bits for storage formats and the
+// higher 4 bits to store level properties. Consider LooseCompressed and
+// TwoOutOfFour as properties instead of formats.
+enum class DimLevelType : uint8_t {
+  Undef = 0,                // 0b00000_00
+  Dense = 4,                // 0b00001_00
+  Compressed = 8,           // 0b00010_00
+  CompressedNu = 9,         // 0b00010_01
+  CompressedNo = 10,        // 0b00010_10
+  CompressedNuNo = 11,      // 0b00010_11
+  Singleton = 16,           // 0b00100_00
+  SingletonNu = 17,         // 0b00100_01
+  SingletonNo = 18,         // 0b00100_10
+  SingletonNuNo = 19,       // 0b00100_11
+  LooseCompressed = 32,     // 0b01000_00
+  LooseCompressedNu = 33,   // 0b01000_01
+  LooseCompressedNo = 34,   // 0b01000_10
+  LooseCompressedNuNo = 35, // 0b01000_11
+  TwoOutOfFour = 64,        // 0b10000_00
+};
+
+/// This enum defines all supported storage format without the level properties.
+enum class LevelFormat : uint8_t {
+  Dense = 4,            // 0b00001_00
+  Compressed = 8,       // 0b00010_00
+  Singleton = 16,       // 0b00100_00
+  LooseCompressed = 32, // 0b01000_00
+  TwoOutOfFour = 64,    // 0b10000_00
+};
+
+/// This enum defines all the nondefault properties for storage formats.
+enum class LevelNondefaultProperty : uint8_t {
+  Nonunique = 1,  // 0b00000_01
+  Nonordered = 2, // 0b00000_10
+};
+
+/// Returns string representation of the given dimension level type.
+constexpr const char *toMLIRString(DimLevelType dlt) {
+  switch (dlt) {
+  case DimLevelType::Undef:
+    return "undef";
+  case DimLevelType::Dense:
+    return "dense";
+  case DimLevelType::Compressed:
+    return "compressed";
+  case DimLevelType::CompressedNu:
+    return "compressed(nonunique)";
+  case DimLevelType::CompressedNo:
+    return "compressed(nonordered)";
+  case DimLevelType::CompressedNuNo:
+    return "compressed(nonunique, nonordered)";
+  case DimLevelType::Singleton:
+    return "singleton";
+  case DimLevelType::SingletonNu:
+    return "singleton(nonunique)";
+  case DimLevelType::SingletonNo:
+    return "singleton(nonordered)";
+  case DimLevelType::SingletonNuNo:
+    return "singleton(nonunique, nonordered)";
+  case DimLevelType::LooseCompressed:
+    return "loose_compressed";
+  case DimLevelType::LooseCompressedNu:
+    return "loose_compressed(nonunique)";
+  case DimLevelType::LooseCompressedNo:
+    return "loose_compressed(nonordered)";
+  case DimLevelType::LooseCompressedNuNo:
+    return "loose_compressed(nonunique, nonordered)";
+  case DimLevelType::TwoOutOfFour:
+    return "block2_4";
+  }
+  return "";
+}
+
+/// Check that the `DimLevelType` contains a valid (possibly undefined) value.
+constexpr bool isValidDLT(DimLevelType dlt) {
+  const uint8_t formatBits = static_cast<uint8_t>(dlt) >> 2;
+  const uint8_t propertyBits = static_cast<uint8_t>(dlt) & 3;
+  // If undefined or dense, then must be unique and ordered.
+  // Otherwise, the format must be one of the known ones.
+  return (formatBits <= 1 || formatBits == 16)
+             ? (propertyBits == 0)
+             : (formatBits == 2 || formatBits == 4 || formatBits == 8);
+}
+
+/// Check if the `DimLevelType` is the special undefined value.
+constexpr bool isUndefDLT(DimLevelType dlt) {
+  return dlt == DimLevelType::Undef;
+}
+
+/// Check if the `DimLevelType` is dense.
+constexpr bool isDenseDLT(DimLevelType dlt) {
+  return dlt == DimLevelType::Dense;
+}
+
+/// Check if the `DimLevelType` is 2:4
+constexpr bool isTwoOutOfFourDLT(DimLevelType dlt) {
+  return dlt == DimLevelType::TwoOutOfFour;
+}
+
+// We use the idiom `(dlt & ~3) == format` in order to only return true
+// for valid DLTs.  Whereas the `dlt & format` idiom is a bit faster but
+// can return false-positives on invalid DLTs.
+
+/// Check if the `DimLevelType` is compressed (regardless of properties).
+constexpr bool isCompressedDLT(DimLevelType dlt) {
+  return (static_cast<uint8_t>(dlt) & ~3) ==
+         static_cast<uint8_t>(DimLevelType::Compressed);
+}
+
+/// Check if the `DimLevelType` is compressed (regardless of properties).
+constexpr bool isLooseCompressedDLT(DimLevelType dlt) {
+  return (static_cast<uint8_t>(dlt) & ~3) ==
+         static_cast<uint8_t>(DimLevelType::LooseCompressed);
+}
+
+/// Check if the `DimLevelType` is singleton (regardless of properties).
+constexpr bool isSingletonDLT(DimLevelType dlt) {
+  return (static_cast<uint8_t>(dlt) & ~3) ==
+         static_cast<uint8_t>(DimLevelType::Singleton);
+}
+
+/// Check if the `DimLevelType` is ordered (regardless of storage format).
+constexpr bool isOrderedDLT(DimLevelType dlt) {
+  return !(static_cast<uint8_t>(dlt) & 2);
+}
+
+/// Check if the `DimLevelType` is unique (regardless of storage format).
+constexpr bool isUniqueDLT(DimLevelType dlt) {
+  return !(static_cast<uint8_t>(dlt) & 1);
+}
+
+/// Convert a DimLevelType to its corresponding LevelFormat.
+/// Returns std::nullopt when input dlt is Undef.
+constexpr std::optional<LevelFormat> getLevelFormat(DimLevelType dlt) {
+  if (dlt == DimLevelType::Undef)
+    return std::nullopt;
+  return static_cast<LevelFormat>(static_cast<uint8_t>(dlt) & ~3);
+}
+
+/// Convert a LevelFormat to its corresponding DimLevelType with the given
+/// properties. Returns std::nullopt when the properties are not applicable for
+/// the input level format.
+/// TODO: factor out a new LevelProperties type so we can add new properties
+/// without changing this function's signature
+constexpr std::optional<DimLevelType>
+buildLevelType(LevelFormat lf, bool ordered, bool unique) {
+  auto dlt = static_cast<DimLevelType>(static_cast<uint8_t>(lf) |
+                                       (ordered ? 0 : 2) | (unique ? 0 : 1));
+  return isValidDLT(dlt) ? std::optional(dlt) : std::nullopt;
+}
+
+/// Ensure the above conversion works as intended.
+static_assert(
+    (getLevelFormat(DimLevelType::Undef) == std::nullopt &&
+     *getLevelFormat(DimLevelType::Dense) == LevelFormat::Dense &&
+     *getLevelFormat(DimLevelType::Compressed) == LevelFormat::Compressed &&
+     *getLevelFormat(DimLevelType::CompressedNu) == LevelFormat::Compressed &&
+     *getLevelFormat(DimLevelType::CompressedNo) == LevelFormat::Compressed &&
+     *getLevelFormat(DimLevelType::CompressedNuNo) == LevelFormat::Compressed &&
+     *getLevelFormat(DimLevelType::Singleton) == LevelFormat::Singleton &&
+     *getLevelFormat(DimLevelType::SingletonNu) == LevelFormat::Singleton &&
+     *getLevelFormat(DimLevelType::SingletonNo) == LevelFormat::Singleton &&
+     *getLevelFormat(DimLevelType::SingletonNuNo) == LevelFormat::Singleton),
+    "getLevelFormat conversion is broken");
+
+static_assert(
+    (buildLevelType(LevelFormat::Dense, false, true) == std::nullopt &&
+     buildLevelType(LevelFormat::Dense, true, false) == std::nullopt &&
+     buildLevelType(LevelFormat::Dense, false, false) == std::nullopt &&
+     *buildLevelType(LevelFormat::Dense, true, true) == DimLevelType::Dense &&
+     buildLevelType(LevelFormat::TwoOutOfFour, false, true) == std::nullopt &&
+     buildLevelType(LevelFormat::TwoOutOfFour, true, false) == std::nullopt &&
+     buildLevelType(LevelFormat::TwoOutOfFour, false, false) == std::nullopt &&
+     *buildLevelType(LevelFormat::TwoOutOfFour, true, true) ==
+         DimLevelType::TwoOutOfFour &&
+     *buildLevelType(LevelFormat::Compressed, true, true) ==
+         DimLevelType::Compressed &&
+     *buildLevelType(LevelFormat::Compressed, true, false) ==
+         DimLevelType::CompressedNu &&
+     *buildLevelType(LevelFormat::Compressed, false, true) ==
+         DimLevelType::CompressedNo &&
+     *buildLevelType(LevelFormat::Compressed, false, false) ==
+         DimLevelType::CompressedNuNo &&
+     *buildLevelType(LevelFormat::Singleton, true, true) ==
+         DimLevelType::Singleton &&
+     *buildLevelType(LevelFormat::Singleton, true, false) ==
+         DimLevelType::SingletonNu &&
+     *buildLevelType(LevelFormat::Singleton, false, true) ==
+         DimLevelType::SingletonNo &&
+     *buildLevelType(LevelFormat::Singleton, false, false) ==
+         DimLevelType::SingletonNuNo),
+    "buildLevelType conversion is broken");
+
+// Ensure the above predicates work as intended.
+static_assert((isValidDLT(DimLevelType::Undef) &&
+               isValidDLT(DimLevelType::Dense) &&
+               isValidDLT(DimLevelType::Compressed) &&
+               isValidDLT(DimLevelType::CompressedNu) &&
+               isValidDLT(DimLevelType::CompressedNo) &&
+               isValidDLT(DimLevelType::CompressedNuNo) &&
+               isValidDLT(DimLevelType::Singleton) &&
+               isValidDLT(DimLevelType::SingletonNu) &&
+               isValidDLT(DimLevelType::SingletonNo) &&
+               isValidDLT(DimLevelType::SingletonNuNo) &&
+               isValidDLT(DimLevelType::LooseCompressed) &&
+               isValidDLT(DimLevelType::LooseCompressedNu) &&
+               isValidDLT(DimLevelType::LooseCompressedNo) &&
+               isValidDLT(DimLevelType::LooseCompressedNuNo) &&
+               isValidDLT(DimLevelType::TwoOutOfFour)),
+              "isValidDLT definition is broken");
+
+static_assert((!isCompressedDLT(DimLevelType::Dense) &&
+               isCompressedDLT(DimLevelType::Compressed) &&
+               isCompressedDLT(DimLevelType::CompressedNu) &&
+               isCompressedDLT(DimLevelType::CompressedNo) &&
+               isCompressedDLT(DimLevelType::CompressedNuNo) &&
+               !isCompressedDLT(DimLevelType::Singleton) &&
+               !isCompressedDLT(DimLevelType::SingletonNu) &&
+               !isCompressedDLT(DimLevelType::SingletonNo) &&
+               !isCompressedDLT(DimLevelType::SingletonNuNo)),
+              "isCompressedDLT definition is broken");
+
+static_assert((!isLooseCompressedDLT(DimLevelType::Dense) &&
+               isLooseCompressedDLT(DimLevelType::LooseCompressed) &&
+               isLooseCompressedDLT(DimLevelType::LooseCompressedNu) &&
+               isLooseCompressedDLT(DimLevelType::LooseCompressedNo) &&
+               isLooseCompressedDLT(DimLevelType::LooseCompressedNuNo) &&
+               !isLooseCompressedDLT(DimLevelType::Singleton) &&
+               !isLooseCompressedDLT(DimLevelType::SingletonNu) &&
+               !isLooseCompressedDLT(DimLevelType::SingletonNo) &&
+               !isLooseCompressedDLT(DimLevelType::SingletonNuNo)),
+              "isLooseCompressedDLT definition is broken");
+
+static_assert((!isSingletonDLT(DimLevelType::Dense) &&
+               !isSingletonDLT(DimLevelType::Compressed) &&
+               !isSingletonDLT(DimLevelType::CompressedNu) &&
+               !isSingletonDLT(DimLevelType::CompressedNo) &&
+               !isSingletonDLT(DimLevelType::CompressedNuNo) &&
+               isSingletonDLT(DimLevelType::Singleton) &&
+               isSingletonDLT(DimLevelType::SingletonNu) &&
+               isSingletonDLT(DimLevelType::SingletonNo) &&
+               isSingletonDLT(DimLevelType::SingletonNuNo)),
+              "isSingletonDLT definition is broken");
+
+static_assert((isOrderedDLT(DimLevelType::Dense) &&
+               isOrderedDLT(DimLevelType::TwoOutOfFour) &&
+               isOrderedDLT(DimLevelType::Compressed) &&
+               isOrderedDLT(DimLevelType::CompressedNu) &&
+               !isOrderedDLT(DimLevelType::CompressedNo) &&
+               !isOrderedDLT(DimLevelType::CompressedNuNo) &&
+               isOrderedDLT(DimLevelType::Singleton) &&
+               isOrderedDLT(DimLevelType::SingletonNu) &&
+               !isOrderedDLT(DimLevelType::SingletonNo) &&
+               !isOrderedDLT(DimLevelType::SingletonNuNo) &&
+               isOrderedDLT(DimLevelType::LooseCompressed) &&
+               isOrderedDLT(DimLevelType::LooseCompressedNu) &&
+               !isOrderedDLT(DimLevelType::LooseCompressedNo) &&
+               !isOrderedDLT(DimLevelType::LooseCompressedNuNo)),
+              "isOrderedDLT definition is broken");
+
+static_assert((isUniqueDLT(DimLevelType::Dense) &&
+               isUniqueDLT(DimLevelType::TwoOutOfFour) &&
+               isUniqueDLT(DimLevelType::Compressed) &&
+               !isUniqueDLT(DimLevelType::CompressedNu) &&
+               isUniqueDLT(DimLevelType::CompressedNo) &&
+               !isUniqueDLT(DimLevelType::CompressedNuNo) &&
+               isUniqueDLT(DimLevelType::Singleton) &&
+               !isUniqueDLT(DimLevelType::SingletonNu) &&
+               isUniqueDLT(DimLevelType::SingletonNo) &&
+               !isUniqueDLT(DimLevelType::SingletonNuNo) &&
+               isUniqueDLT(DimLevelType::LooseCompressed) &&
+               !isUniqueDLT(DimLevelType::LooseCompressedNu) &&
+               isUniqueDLT(DimLevelType::LooseCompressedNo) &&
+               !isUniqueDLT(DimLevelType::LooseCompressedNuNo)),
+              "isUniqueDLT definition is broken");
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_IR_ENUMS_H

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensor.h

@@ -0,0 +1,197 @@
+//===- SparseTensor.h - Sparse tensor dialect -------------------*- 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_SPARSETENSOR_IR_SPARSETENSOR_H_
+#define MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSOR_H_
+
+#include "mlir/Bytecode/BytecodeOpInterface.h"
+#include "mlir/Dialect/SparseTensor/IR/Enums.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/TensorEncoding.h"
+#include "mlir/Interfaces/InferTypeOpInterface.h"
+#include "mlir/Interfaces/SideEffectInterfaces.h"
+
+//===----------------------------------------------------------------------===//
+//
+// Type aliases to help code be more self-documenting.  Unfortunately
+// these are not type-checked, so they only provide documentation rather
+// than doing anything to prevent mixups.
+//
+// We must include these here (rather than in "SparseTensorType.h")
+// because they are used by methods declared in the tablegen files.
+//
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+namespace sparse_tensor {
+
+/// The type of dimension identifiers, and dimension-ranks.  We use the
+/// same type for both identifiers and ranks because the latter are used
+/// mainly for ordering-comparisons against the former (just like how the
+/// one-past-the-end iterators are used).
+using Dimension = uint64_t;
+
+/// The type of level identifiers, and level-ranks.  We use the same
+/// type for both identifiers and ranks because the latter are used
+/// mainly for ordering-comparisons against the former (just like how
+/// the one-past-the-end iterators are used).
+using Level = uint64_t;
+
+/// The type for individual components of a compile-time shape.  We avoid
+/// calling this "size" because we use the term "sizes" to indicate the
+/// actual run-time sizes, whereas this type also allows the value
+/// `ShapedType::kDynamic`.
+using DynSize = int64_t;
+
+/// The type for individual components of a compile-time shape which
+/// are known not to be `ShapedType::kDynamic`.
+using StaticSize = int64_t;
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// TableGen-defined classes
+//===----------------------------------------------------------------------===//
+
+// We must include Enums.h.inc before AttrDefs.h.inc due to dependency between
+// StorageSpecifierKindAttr and StorageSpeciferKind Enum.
+
+#define GET_ATTRDEF_CLASSES
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorAttrEnums.h.inc"
+
+#define GET_ATTRDEF_CLASSES
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.h.inc"
+
+#define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorTypes.h.inc"
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorOps.h.inc"
+
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorOpsDialect.h.inc"
+
+//===----------------------------------------------------------------------===//
+// Additional convenience methods.
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+namespace sparse_tensor {
+
+// NOTE: `Value::getType` doesn't check for null before trying to
+// dereference things.  Therefore we check, because an assertion-failure
+// is easier to debug than a segfault.  Presumably other `T::getType`
+// methods are similarly susceptible.
+
+/// Convenience method to abbreviate casting `getType()`.
+template <typename T>
+inline RankedTensorType getRankedTensorType(T &&t) {
+  assert(static_cast<bool>(std::forward<T>(t)) &&
+         "getRankedTensorType got null argument");
+  return cast<RankedTensorType>(std::forward<T>(t).getType());
+}
+
+/// Convenience method to abbreviate casting `getType()`.
+template <typename T>
+inline MemRefType getMemRefType(T &&t) {
+  assert(static_cast<bool>(std::forward<T>(t)) &&
+         "getMemRefType got null argument");
+  return cast<MemRefType>(std::forward<T>(t).getType());
+}
+
+/// Convenience method to get a sparse encoding attribute from a type.
+/// Returns null-attribute for any type without an encoding.
+SparseTensorEncodingAttr getSparseTensorEncoding(Type type);
+
+/// Convenience method to query whether a given DLT needs both position and
+/// coordinates array or only coordinates array.
+constexpr inline bool isDLTWithPos(DimLevelType dlt) {
+  return isLooseCompressedDLT(dlt) || isCompressedDLT(dlt);
+}
+constexpr inline bool isDLTWithCrd(DimLevelType dlt) {
+  return isSingletonDLT(dlt) || isLooseCompressedDLT(dlt) ||
+         isCompressedDLT(dlt);
+}
+
+/// Returns true iff the given sparse tensor encoding attribute has a trailing
+/// COO region starting at the given level.
+bool isCOOType(SparseTensorEncodingAttr enc, Level startLvl, bool isUnique);
+
+/// Returns true iff the given type is a COO type where the last level
+/// is unique.
+bool isUniqueCOOType(Type tp);
+
+/// Returns the starting level for a trailing COO region that spans
+/// at least two levels.  If no such COO region is found, then returns
+/// the level-rank.
+Level getCOOStart(SparseTensorEncodingAttr enc);
+
+/// Helpers to setup a COO type.
+RankedTensorType getCOOFromTypeWithOrdering(RankedTensorType src,
+                                            AffineMap ordering, bool ordered);
+
+RankedTensorType getCOOFromType(RankedTensorType src, bool ordered);
+
+/// Returns true iff MLIR operand has any sparse operand.
+inline bool hasAnySparseOperand(Operation *op) {
+  return llvm::any_of(op->getOperands().getTypes(), [](Type t) {
+    return getSparseTensorEncoding(t) != nullptr;
+  });
+}
+
+/// Returns true iff MLIR operand has any sparse result.
+inline bool hasAnySparseResult(Operation *op) {
+  return llvm::any_of(op->getResults().getTypes(), [](Type t) {
+    return getSparseTensorEncoding(t) != nullptr;
+  });
+}
+
+/// Returns true iff MLIR operand has any sparse operand or result.
+inline bool hasAnySparseOperandOrResult(Operation *op) {
+  return hasAnySparseOperand(op) || hasAnySparseResult(op);
+}
+
+//
+// Reordering.
+//
+
+// This CPP guard is to disable deprecation warnings for the LLVM
+// build-bot, while making it easy to re-enable it for local development.
+#if 0
+#define DEPRECATED                                                             \
+  LLVM_DEPRECATED("The toOrigDim/toStoredDim functions are deprecated "        \
+                  "because they only work for permutations; therefore any "    \
+                  "code using them cannot support non-permutations.",          \
+                  "")
+#else
+#define DEPRECATED
+#endif
+
+/// [deprecated] Convenience method to translate the given level to the
+/// corresponding dimension.  Requires: `0 <= l < lvlRank`.
+DEPRECATED Dimension toOrigDim(SparseTensorEncodingAttr enc, Level l);
+DEPRECATED Dimension toOrigDim(RankedTensorType type, Level l);
+
+/// [deprecated] Convenience method to translate the given dimension to
+/// the corresponding level.  Requires: `0 <= d < dimRank`.
+DEPRECATED Level toStoredDim(SparseTensorEncodingAttr enc, Dimension d);
+DEPRECATED Level toStoredDim(RankedTensorType type, Dimension d);
+
+#undef DEPRECATED
+
+namespace detail {
+Type getIntegerOrIndexType(MLIRContext *ctx, unsigned bitwidth);
+} // namespace detail
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSOR_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.cpp.inc

@@ -0,0 +1,386 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* AttrDef Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_ATTRDEF_LIST
+#undef GET_ATTRDEF_LIST
+
+::mlir::sparse_tensor::SparseTensorDimSliceAttr,
+::mlir::sparse_tensor::SparseTensorEncodingAttr,
+::mlir::sparse_tensor::SparseTensorSortKindAttr,
+::mlir::sparse_tensor::StorageSpecifierKindAttr
+
+#endif  // GET_ATTRDEF_LIST
+
+#ifdef GET_ATTRDEF_CLASSES
+#undef GET_ATTRDEF_CLASSES
+
+static ::mlir::OptionalParseResult generatedAttributeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type type, ::mlir::Attribute &value) {
+  return ::mlir::AsmParser::KeywordSwitch<::mlir::OptionalParseResult>(parser)
+    .Case(::mlir::sparse_tensor::SparseTensorDimSliceAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::sparse_tensor::SparseTensorDimSliceAttr::parse(parser, type);
+      return ::mlir::success(!!value);
+    })
+    .Case(::mlir::sparse_tensor::SparseTensorEncodingAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::sparse_tensor::SparseTensorEncodingAttr::parse(parser, type);
+      return ::mlir::success(!!value);
+    })
+    .Case(::mlir::sparse_tensor::SparseTensorSortKindAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::sparse_tensor::SparseTensorSortKindAttr::parse(parser, type);
+      return ::mlir::success(!!value);
+    })
+    .Case(::mlir::sparse_tensor::StorageSpecifierKindAttr::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::sparse_tensor::StorageSpecifierKindAttr::parse(parser, type);
+      return ::mlir::success(!!value);
+    })
+    .Default([&](llvm::StringRef keyword, llvm::SMLoc) {
+      *mnemonic = keyword;
+      return std::nullopt;
+    });
+}
+
+static ::mlir::LogicalResult generatedAttributePrinter(::mlir::Attribute def, ::mlir::AsmPrinter &printer) {
+  return ::llvm::TypeSwitch<::mlir::Attribute, ::mlir::LogicalResult>(def)    .Case<::mlir::sparse_tensor::SparseTensorDimSliceAttr>([&](auto t) {
+      printer << ::mlir::sparse_tensor::SparseTensorDimSliceAttr::getMnemonic();
+t.print(printer);
+      return ::mlir::success();
+    })
+    .Case<::mlir::sparse_tensor::SparseTensorEncodingAttr>([&](auto t) {
+      printer << ::mlir::sparse_tensor::SparseTensorEncodingAttr::getMnemonic();
+t.print(printer);
+      return ::mlir::success();
+    })
+    .Case<::mlir::sparse_tensor::SparseTensorSortKindAttr>([&](auto t) {
+      printer << ::mlir::sparse_tensor::SparseTensorSortKindAttr::getMnemonic();
+t.print(printer);
+      return ::mlir::success();
+    })
+    .Case<::mlir::sparse_tensor::StorageSpecifierKindAttr>([&](auto t) {
+      printer << ::mlir::sparse_tensor::StorageSpecifierKindAttr::getMnemonic();
+t.print(printer);
+      return ::mlir::success();
+    })
+    .Default([](auto) { return ::mlir::failure(); });
+}
+
+namespace mlir {
+namespace sparse_tensor {
+namespace detail {
+struct SparseTensorDimSliceAttrStorage : public ::mlir::AttributeStorage {
+  using KeyTy = std::tuple<int64_t, int64_t, int64_t>;
+  SparseTensorDimSliceAttrStorage(int64_t offset, int64_t size, int64_t stride) : offset(std::move(offset)), size(std::move(size)), stride(std::move(stride)) {}
+
+  KeyTy getAsKey() const {
+    return KeyTy(offset, size, stride);
+  }
+
+  bool operator==(const KeyTy &tblgenKey) const {
+    return (offset == std::get<0>(tblgenKey)) && (size == std::get<1>(tblgenKey)) && (stride == std::get<2>(tblgenKey));
+  }
+
+  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
+    return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey), std::get<2>(tblgenKey));
+  }
+
+  static SparseTensorDimSliceAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
+    auto offset = std::move(std::get<0>(tblgenKey));
+    auto size = std::move(std::get<1>(tblgenKey));
+    auto stride = std::move(std::get<2>(tblgenKey));
+    return new (allocator.allocate<SparseTensorDimSliceAttrStorage>()) SparseTensorDimSliceAttrStorage(std::move(offset), std::move(size), std::move(stride));
+  }
+
+  int64_t offset;
+  int64_t size;
+  int64_t stride;
+};
+} // namespace detail
+SparseTensorDimSliceAttr SparseTensorDimSliceAttr::get(::mlir::MLIRContext *context, int64_t offset, int64_t size, int64_t stride) {
+  return Base::get(context, std::move(offset), std::move(size), std::move(stride));
+}
+
+SparseTensorDimSliceAttr SparseTensorDimSliceAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int64_t offset, int64_t size, int64_t stride) {
+  return Base::getChecked(emitError, context, offset, size, stride);
+}
+
+SparseTensorDimSliceAttr SparseTensorDimSliceAttr::get(::mlir::MLIRContext *context) {
+  return Base::get(context, 0, kDynamic, 1); 
+}
+
+SparseTensorDimSliceAttr SparseTensorDimSliceAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context) {
+  return Base::getChecked(emitError, context, 0, kDynamic, 1); 
+}
+
+int64_t SparseTensorDimSliceAttr::getOffset() const {
+  return getImpl()->offset;
+}
+
+int64_t SparseTensorDimSliceAttr::getSize() const {
+  return getImpl()->size;
+}
+
+int64_t SparseTensorDimSliceAttr::getStride() const {
+  return getImpl()->stride;
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorDimSliceAttr)
+namespace mlir {
+namespace sparse_tensor {
+namespace detail {
+struct SparseTensorEncodingAttrStorage : public ::mlir::AttributeStorage {
+  using KeyTy = std::tuple<::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType>, AffineMap, AffineMap, unsigned, unsigned, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr>>;
+  SparseTensorEncodingAttrStorage(::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices) : lvlTypes(std::move(lvlTypes)), dimToLvl(std::move(dimToLvl)), lvlToDim(std::move(lvlToDim)), posWidth(std::move(posWidth)), crdWidth(std::move(crdWidth)), dimSlices(std::move(dimSlices)) {}
+
+  KeyTy getAsKey() const {
+    return KeyTy(lvlTypes, dimToLvl, lvlToDim, posWidth, crdWidth, dimSlices);
+  }
+
+  bool operator==(const KeyTy &tblgenKey) const {
+    return (lvlTypes == std::get<0>(tblgenKey)) && (dimToLvl == std::get<1>(tblgenKey)) && (lvlToDim == std::get<2>(tblgenKey)) && (posWidth == std::get<3>(tblgenKey)) && (crdWidth == std::get<4>(tblgenKey)) && (dimSlices == std::get<5>(tblgenKey));
+  }
+
+  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
+    return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey), std::get<2>(tblgenKey), std::get<3>(tblgenKey), std::get<4>(tblgenKey), std::get<5>(tblgenKey));
+  }
+
+  static SparseTensorEncodingAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
+    auto lvlTypes = std::move(std::get<0>(tblgenKey));
+    auto dimToLvl = std::move(std::get<1>(tblgenKey));
+    auto lvlToDim = std::move(std::get<2>(tblgenKey));
+    auto posWidth = std::move(std::get<3>(tblgenKey));
+    auto crdWidth = std::move(std::get<4>(tblgenKey));
+    auto dimSlices = std::move(std::get<5>(tblgenKey));
+    lvlTypes = allocator.copyInto(lvlTypes);
+    dimSlices = allocator.copyInto(dimSlices);
+    return new (allocator.allocate<SparseTensorEncodingAttrStorage>()) SparseTensorEncodingAttrStorage(std::move(lvlTypes), std::move(dimToLvl), std::move(lvlToDim), std::move(posWidth), std::move(crdWidth), std::move(dimSlices));
+  }
+
+  ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes;
+  AffineMap dimToLvl;
+  AffineMap lvlToDim;
+  unsigned posWidth;
+  unsigned crdWidth;
+  ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices;
+};
+} // namespace detail
+SparseTensorEncodingAttr SparseTensorEncodingAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices) {
+  return Base::get(context, std::move(lvlTypes), std::move(dimToLvl), std::move(lvlToDim), std::move(posWidth), std::move(crdWidth), std::move(dimSlices));
+}
+
+SparseTensorEncodingAttr SparseTensorEncodingAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices) {
+  return Base::getChecked(emitError, context, lvlTypes, dimToLvl, lvlToDim, posWidth, crdWidth, dimSlices);
+}
+
+SparseTensorEncodingAttr SparseTensorEncodingAttr::get(::mlir::MLIRContext *context, ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth) {
+  return Base::get(context, lvlTypes, dimToLvl, lvlToDim, posWidth, crdWidth,
+    ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr>{});
+}
+
+SparseTensorEncodingAttr SparseTensorEncodingAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth) {
+  return Base::getChecked(emitError, context, lvlTypes, dimToLvl, lvlToDim, posWidth, crdWidth,
+    ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr>{});
+}
+
+::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> SparseTensorEncodingAttr::getLvlTypes() const {
+  return getImpl()->lvlTypes;
+}
+
+AffineMap SparseTensorEncodingAttr::getDimToLvl() const {
+  return getImpl()->dimToLvl;
+}
+
+AffineMap SparseTensorEncodingAttr::getLvlToDim() const {
+  return getImpl()->lvlToDim;
+}
+
+unsigned SparseTensorEncodingAttr::getPosWidth() const {
+  return getImpl()->posWidth;
+}
+
+unsigned SparseTensorEncodingAttr::getCrdWidth() const {
+  return getImpl()->crdWidth;
+}
+
+::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> SparseTensorEncodingAttr::getDimSlices() const {
+  return getImpl()->dimSlices;
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorEncodingAttr)
+namespace mlir {
+namespace sparse_tensor {
+namespace detail {
+struct SparseTensorSortKindAttrStorage : public ::mlir::AttributeStorage {
+  using KeyTy = std::tuple<::mlir::sparse_tensor::SparseTensorSortKind>;
+  SparseTensorSortKindAttrStorage(::mlir::sparse_tensor::SparseTensorSortKind value) : value(std::move(value)) {}
+
+  KeyTy getAsKey() const {
+    return KeyTy(value);
+  }
+
+  bool operator==(const KeyTy &tblgenKey) const {
+    return (value == std::get<0>(tblgenKey));
+  }
+
+  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
+    return ::llvm::hash_combine(std::get<0>(tblgenKey));
+  }
+
+  static SparseTensorSortKindAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
+    auto value = std::move(std::get<0>(tblgenKey));
+    return new (allocator.allocate<SparseTensorSortKindAttrStorage>()) SparseTensorSortKindAttrStorage(std::move(value));
+  }
+
+  ::mlir::sparse_tensor::SparseTensorSortKind value;
+};
+} // namespace detail
+SparseTensorSortKindAttr SparseTensorSortKindAttr::get(::mlir::MLIRContext *context, ::mlir::sparse_tensor::SparseTensorSortKind value) {
+  return Base::get(context, std::move(value));
+}
+
+::mlir::Attribute SparseTensorSortKindAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
+  ::mlir::Builder odsBuilder(odsParser.getContext());
+  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
+  (void) odsLoc;
+  ::mlir::FailureOr<::mlir::sparse_tensor::SparseTensorSortKind> _result_value;
+
+  // Parse variable 'value'
+  _result_value = [&]() -> ::mlir::FailureOr<::mlir::sparse_tensor::SparseTensorSortKind> {
+      auto loc = odsParser.getCurrentLocation();
+      ::llvm::StringRef enumKeyword;
+      if (::mlir::failed(odsParser.parseKeyword(&enumKeyword)))
+        return ::mlir::failure();
+      auto maybeEnum = ::mlir::sparse_tensor::symbolizeSparseTensorSortKind(enumKeyword);
+      if (maybeEnum)
+        return *maybeEnum;
+      return {(::mlir::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::sparse_tensor::SparseTensorSortKind" << " to be one of: " << "hybrid_quick_sort" << ", " << "insertion_sort_stable" << ", " << "quick_sort" << ", " << "heap_sort")};
+    }();
+  if (::mlir::failed(_result_value)) {
+    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse SparseTensorSortKindAttr parameter 'value' which is to be a `::mlir::sparse_tensor::SparseTensorSortKind`");
+    return {};
+  }
+  assert(::mlir::succeeded(_result_value));
+  return SparseTensorSortKindAttr::get(odsParser.getContext(),
+      ::mlir::sparse_tensor::SparseTensorSortKind((*_result_value)));
+}
+
+void SparseTensorSortKindAttr::print(::mlir::AsmPrinter &odsPrinter) const {
+  ::mlir::Builder odsBuilder(getContext());
+  odsPrinter << ' ';
+  odsPrinter << stringifySparseTensorSortKind(getValue());
+}
+
+::mlir::sparse_tensor::SparseTensorSortKind SparseTensorSortKindAttr::getValue() const {
+  return getImpl()->value;
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorSortKindAttr)
+namespace mlir {
+namespace sparse_tensor {
+namespace detail {
+struct StorageSpecifierKindAttrStorage : public ::mlir::AttributeStorage {
+  using KeyTy = std::tuple<::mlir::sparse_tensor::StorageSpecifierKind>;
+  StorageSpecifierKindAttrStorage(::mlir::sparse_tensor::StorageSpecifierKind value) : value(std::move(value)) {}
+
+  KeyTy getAsKey() const {
+    return KeyTy(value);
+  }
+
+  bool operator==(const KeyTy &tblgenKey) const {
+    return (value == std::get<0>(tblgenKey));
+  }
+
+  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
+    return ::llvm::hash_combine(std::get<0>(tblgenKey));
+  }
+
+  static StorageSpecifierKindAttrStorage *construct(::mlir::AttributeStorageAllocator &allocator, KeyTy &&tblgenKey) {
+    auto value = std::move(std::get<0>(tblgenKey));
+    return new (allocator.allocate<StorageSpecifierKindAttrStorage>()) StorageSpecifierKindAttrStorage(std::move(value));
+  }
+
+  ::mlir::sparse_tensor::StorageSpecifierKind value;
+};
+} // namespace detail
+StorageSpecifierKindAttr StorageSpecifierKindAttr::get(::mlir::MLIRContext *context, ::mlir::sparse_tensor::StorageSpecifierKind value) {
+  return Base::get(context, std::move(value));
+}
+
+::mlir::Attribute StorageSpecifierKindAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {
+  ::mlir::Builder odsBuilder(odsParser.getContext());
+  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
+  (void) odsLoc;
+  ::mlir::FailureOr<::mlir::sparse_tensor::StorageSpecifierKind> _result_value;
+
+  // Parse variable 'value'
+  _result_value = [&]() -> ::mlir::FailureOr<::mlir::sparse_tensor::StorageSpecifierKind> {
+      auto loc = odsParser.getCurrentLocation();
+      ::llvm::StringRef enumKeyword;
+      if (::mlir::failed(odsParser.parseKeyword(&enumKeyword)))
+        return ::mlir::failure();
+      auto maybeEnum = ::mlir::sparse_tensor::symbolizeStorageSpecifierKind(enumKeyword);
+      if (maybeEnum)
+        return *maybeEnum;
+      return {(::mlir::LogicalResult)(odsParser.emitError(loc) << "expected " << "::mlir::sparse_tensor::StorageSpecifierKind" << " to be one of: " << "lvl_sz" << ", " << "pos_mem_sz" << ", " << "crd_mem_sz" << ", " << "val_mem_sz" << ", " << "dim_offset" << ", " << "dim_stride")};
+    }();
+  if (::mlir::failed(_result_value)) {
+    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse SparseTensorStorageSpecifierKindAttr parameter 'value' which is to be a `::mlir::sparse_tensor::StorageSpecifierKind`");
+    return {};
+  }
+  assert(::mlir::succeeded(_result_value));
+  return StorageSpecifierKindAttr::get(odsParser.getContext(),
+      ::mlir::sparse_tensor::StorageSpecifierKind((*_result_value)));
+}
+
+void StorageSpecifierKindAttr::print(::mlir::AsmPrinter &odsPrinter) const {
+  ::mlir::Builder odsBuilder(getContext());
+  odsPrinter << ' ';
+  odsPrinter << stringifyStorageSpecifierKind(getValue());
+}
+
+::mlir::sparse_tensor::StorageSpecifierKind StorageSpecifierKindAttr::getValue() const {
+  return getImpl()->value;
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::StorageSpecifierKindAttr)
+namespace mlir {
+namespace sparse_tensor {
+
+/// Parse an attribute registered to this dialect.
+::mlir::Attribute SparseTensorDialect::parseAttribute(::mlir::DialectAsmParser &parser,
+                                      ::mlir::Type type) const {
+  ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  ::llvm::StringRef attrTag;
+  {
+    ::mlir::Attribute attr;
+    auto parseResult = generatedAttributeParser(parser, &attrTag, type, attr);
+    if (parseResult.has_value())
+      return attr;
+  }
+  
+  parser.emitError(typeLoc) << "unknown attribute `"
+      << attrTag << "` in dialect `" << getNamespace() << "`";
+  return {};
+}
+/// Print an attribute registered to this dialect.
+void SparseTensorDialect::printAttribute(::mlir::Attribute attr,
+                         ::mlir::DialectAsmPrinter &printer) const {
+  if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
+    return;
+  
+}
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif  // GET_ATTRDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.h.inc

@@ -0,0 +1,238 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* AttrDef Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_ATTRDEF_CLASSES
+#undef GET_ATTRDEF_CLASSES
+
+
+namespace mlir {
+class AsmParser;
+class AsmPrinter;
+} // namespace mlir
+namespace mlir {
+namespace sparse_tensor {
+class SparseTensorDimSliceAttr;
+class SparseTensorEncodingAttr;
+class SparseTensorSortKindAttr;
+class StorageSpecifierKindAttr;
+namespace detail {
+struct SparseTensorDimSliceAttrStorage;
+} // namespace detail
+class SparseTensorDimSliceAttr : public ::mlir::Attribute::AttrBase<SparseTensorDimSliceAttr, ::mlir::Attribute, detail::SparseTensorDimSliceAttrStorage> {
+public:
+  using Base::Base;
+  void print(llvm::raw_ostream &os) const;
+
+  /// Special value for dynamic offset/size/stride.
+  static constexpr int64_t kDynamic = -1;
+  static constexpr bool isDynamic(int64_t v) { return v == kDynamic; }
+  static std::optional<uint64_t> getStatic(int64_t v);
+  static std::string getStaticString(int64_t v);
+
+  std::optional<uint64_t> getStaticOffset() const;
+  std::optional<uint64_t> getStaticStride() const;
+  std::optional<uint64_t> getStaticSize() const;
+  bool isCompletelyDynamic() const;
+  using Base::getChecked;
+  static SparseTensorDimSliceAttr get(::mlir::MLIRContext *context, int64_t offset, int64_t size, int64_t stride);
+  static SparseTensorDimSliceAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int64_t offset, int64_t size, int64_t stride);
+  static SparseTensorDimSliceAttr get(::mlir::MLIRContext *context);
+  static SparseTensorDimSliceAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context);
+  static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int64_t offset, int64_t size, int64_t stride);
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"slice"};
+  }
+
+  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
+  void print(::mlir::AsmPrinter &odsPrinter) const;
+  int64_t getOffset() const;
+  int64_t getSize() const;
+  int64_t getStride() const;
+};
+namespace detail {
+struct SparseTensorEncodingAttrStorage;
+} // namespace detail
+class SparseTensorEncodingAttr : public ::mlir::Attribute::AttrBase<SparseTensorEncodingAttr, ::mlir::Attribute, detail::SparseTensorEncodingAttrStorage, ::mlir::VerifiableTensorEncoding::Trait> {
+public:
+  using Base::Base;
+  //
+  // Factory methods.
+  //
+
+  /// Constructs a new encoding with the given dimToLvl mapping,
+  /// and all other fields inherited from `this`.
+  SparseTensorEncodingAttr withDimToLvl(AffineMap dimToLvl) const;
+  SparseTensorEncodingAttr withDimToLvl(SparseTensorEncodingAttr enc) const;
+
+  /// Constructs a new encoding with dimToLvl reset to the default/identity,
+  /// and all other fields inherited from `this`.
+  SparseTensorEncodingAttr withoutDimToLvl() const;
+
+  /// Constructs a new encoding with the given pointer and index
+  /// bitwidths, and all other fields inherited from `this`.
+  SparseTensorEncodingAttr withBitWidths(unsigned posWidth, unsigned crdWidth) const;
+
+  /// Constructs a new encoding with the pointer and index bitwidths
+  /// reset to the default, and all other fields inherited from `this`.
+  SparseTensorEncodingAttr withoutBitWidths() const;
+
+  /// Constructs a new encoding with the given dimSlices, and all
+  /// other fields inherited from `this`.
+  SparseTensorEncodingAttr withDimSlices(ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices) const;
+
+  /// Constructs a new encoding with the dimSlices reset to the default,
+  /// and all other fields inherited from `this`.
+  SparseTensorEncodingAttr withoutDimSlices() const;
+
+  //
+  // Rank methods.
+  //
+
+  /// Returns the expected number of tensor dimensions.  Asserts that
+  /// the encoding is non-null (since no fixed result is valid for every
+  /// dense-tensor).
+  ::mlir::sparse_tensor::Dimension getDimRank() const;
+
+  /// Returns the number of storage levels.  Asserts that the encoding
+  /// is non-null (since no fixed result is valid for every dense-tensor).
+  ::mlir::sparse_tensor::Level getLvlRank() const;
+
+  //
+  // lvlTypes methods.
+  //
+
+  /// Safely looks up the level-type for the requested level.  (Returns
+  /// `DimLevelType::Dense` for the null encoding, since dense-tensors
+  /// are always all-dense.)
+  ::mlir::sparse_tensor::DimLevelType getLvlType(::mlir::sparse_tensor::Level l) const;
+
+  bool isDenseLvl(::mlir::sparse_tensor::Level l) const { return isDenseDLT(getLvlType(l)); }
+  bool isTwoOutOfFourLvl(::mlir::sparse_tensor::Level l) const { return isTwoOutOfFourDLT(getLvlType(l)); }
+  bool isCompressedLvl(::mlir::sparse_tensor::Level l) const { return isCompressedDLT(getLvlType(l)); }
+  bool isLooseCompressedLvl(::mlir::sparse_tensor::Level l) const { return isLooseCompressedDLT(getLvlType(l)); }
+  bool isSingletonLvl(::mlir::sparse_tensor::Level l) const { return isSingletonDLT(getLvlType(l)); }
+  bool isOrderedLvl(::mlir::sparse_tensor::Level l) const { return isOrderedDLT(getLvlType(l)); }
+  bool isUniqueLvl(::mlir::sparse_tensor::Level l) const { return isUniqueDLT(getLvlType(l)); }
+
+  /// Returns true if every level is dense.  Also returns true for
+  /// the null encoding (since dense-tensors are always all-dense).
+  bool isAllDense() const;
+
+  /// Returns true if every level is ordered.  Also returns true for
+  /// the null encoding (since dense-tensors are always all-ordered).
+  bool isAllOrdered() const;
+
+  //
+  // dimToLvl methods.
+  //
+
+  /// Returns true if the dimToLvl mapping is the identity.
+  /// Also returns true for the null encoding (since dense-tensors
+  /// always have the identity mapping).
+  bool isIdentity() const;
+
+  /// Returns true if the dimToLvl mapping is a permutation.
+  /// Also returns true for the null encoding (since dense-tensors
+  /// always have the identity mapping).
+  bool isPermutation() const;
+
+  //
+  // posWidth/crdWidth methods.
+  //
+
+  /// Returns the type for position storage based on posWidth.
+  /// Asserts that the encoding is non-null (since there's nowhere
+  /// to get the `MLIRContext` from).
+  Type getPosType() const;
+
+  /// Returns the type for coordinate storage based on crdWidth.
+  /// Asserts that the encoding is non-null (since there's nowhere
+  /// to get the `MLIRContext` from).
+  Type getCrdType() const;
+
+  //
+  // dimSlices methods.
+  //
+
+  bool isSlice() const;
+
+  ::mlir::sparse_tensor::SparseTensorDimSliceAttr getDimSlice(::mlir::sparse_tensor::Dimension dim) const;
+
+  std::optional<uint64_t> getStaticDimSliceOffset(::mlir::sparse_tensor::Dimension dim) const;
+  std::optional<uint64_t> getStaticDimSliceSize(::mlir::sparse_tensor::Dimension dim) const;
+  std::optional<uint64_t> getStaticDimSliceStride(::mlir::sparse_tensor::Dimension dim) const;
+  std::optional<uint64_t> getStaticLvlSliceOffset(::mlir::sparse_tensor::Level lvl) const;
+  std::optional<uint64_t> getStaticLvlSliceSize(::mlir::sparse_tensor::Level lvl) const;
+  std::optional<uint64_t> getStaticLvlSliceStride(::mlir::sparse_tensor::Level lvl) const;
+
+  //
+  // Printing methods.
+  //
+
+  void printSymbols(AffineMap &map, AsmPrinter &printer) const;
+  void printDimensions(AffineMap &map, AsmPrinter &printer, ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices) const;
+  void printLevels(AffineMap &map, AsmPrinter &printer, ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes) const;
+  using Base::getChecked;
+  static SparseTensorEncodingAttr get(::mlir::MLIRContext *context, ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices);
+  static SparseTensorEncodingAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices);
+  static SparseTensorEncodingAttr get(::mlir::MLIRContext *context, ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth);
+  static SparseTensorEncodingAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth);
+  static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> lvlTypes, AffineMap dimToLvl, AffineMap lvlToDim, unsigned posWidth, unsigned crdWidth, ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> dimSlices);
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"encoding"};
+  }
+
+  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
+  void print(::mlir::AsmPrinter &odsPrinter) const;
+  ::llvm::ArrayRef<::mlir::sparse_tensor::DimLevelType> getLvlTypes() const;
+  AffineMap getDimToLvl() const;
+  AffineMap getLvlToDim() const;
+  unsigned getPosWidth() const;
+  unsigned getCrdWidth() const;
+  ::llvm::ArrayRef<::mlir::sparse_tensor::SparseTensorDimSliceAttr> getDimSlices() const;
+  ::mlir::LogicalResult verifyEncoding(ArrayRef<int64_t> shape, Type elementType, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
+};
+namespace detail {
+struct SparseTensorSortKindAttrStorage;
+} // namespace detail
+class SparseTensorSortKindAttr : public ::mlir::Attribute::AttrBase<SparseTensorSortKindAttr, ::mlir::Attribute, detail::SparseTensorSortKindAttrStorage> {
+public:
+  using Base::Base;
+  static SparseTensorSortKindAttr get(::mlir::MLIRContext *context, ::mlir::sparse_tensor::SparseTensorSortKind value);
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"SparseTensorSortAlgorithm"};
+  }
+
+  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
+  void print(::mlir::AsmPrinter &odsPrinter) const;
+  ::mlir::sparse_tensor::SparseTensorSortKind getValue() const;
+};
+namespace detail {
+struct StorageSpecifierKindAttrStorage;
+} // namespace detail
+class StorageSpecifierKindAttr : public ::mlir::Attribute::AttrBase<StorageSpecifierKindAttr, ::mlir::Attribute, detail::StorageSpecifierKindAttrStorage> {
+public:
+  using Base::Base;
+  static StorageSpecifierKindAttr get(::mlir::MLIRContext *context, ::mlir::sparse_tensor::StorageSpecifierKind value);
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"kind"};
+  }
+
+  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
+  void print(::mlir::AsmPrinter &odsPrinter) const;
+  ::mlir::sparse_tensor::StorageSpecifierKind getValue() const;
+};
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorDimSliceAttr)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorEncodingAttr)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorSortKindAttr)
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::StorageSpecifierKindAttr)
+
+#endif  // GET_ATTRDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrEnums.cpp.inc

@@ -0,0 +1,81 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Enum Utility Definitions                                                   *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SparseTensorAttrDefs.td                                              *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+namespace mlir {
+namespace sparse_tensor {
+::llvm::StringRef stringifySparseTensorSortKind(SparseTensorSortKind val) {
+  switch (val) {
+    case SparseTensorSortKind::HybridQuickSort: return "hybrid_quick_sort";
+    case SparseTensorSortKind::InsertionSortStable: return "insertion_sort_stable";
+    case SparseTensorSortKind::QuickSort: return "quick_sort";
+    case SparseTensorSortKind::HeapSort: return "heap_sort";
+  }
+  return "";
+}
+
+::std::optional<SparseTensorSortKind> symbolizeSparseTensorSortKind(::llvm::StringRef str) {
+  return ::llvm::StringSwitch<::std::optional<SparseTensorSortKind>>(str)
+      .Case("hybrid_quick_sort", SparseTensorSortKind::HybridQuickSort)
+      .Case("insertion_sort_stable", SparseTensorSortKind::InsertionSortStable)
+      .Case("quick_sort", SparseTensorSortKind::QuickSort)
+      .Case("heap_sort", SparseTensorSortKind::HeapSort)
+      .Default(::std::nullopt);
+}
+::std::optional<SparseTensorSortKind> symbolizeSparseTensorSortKind(uint32_t value) {
+  switch (value) {
+  case 0: return SparseTensorSortKind::HybridQuickSort;
+  case 1: return SparseTensorSortKind::InsertionSortStable;
+  case 2: return SparseTensorSortKind::QuickSort;
+  case 3: return SparseTensorSortKind::HeapSort;
+  default: return ::std::nullopt;
+  }
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+namespace mlir {
+namespace sparse_tensor {
+::llvm::StringRef stringifyStorageSpecifierKind(StorageSpecifierKind val) {
+  switch (val) {
+    case StorageSpecifierKind::LvlSize: return "lvl_sz";
+    case StorageSpecifierKind::PosMemSize: return "pos_mem_sz";
+    case StorageSpecifierKind::CrdMemSize: return "crd_mem_sz";
+    case StorageSpecifierKind::ValMemSize: return "val_mem_sz";
+    case StorageSpecifierKind::DimOffset: return "dim_offset";
+    case StorageSpecifierKind::DimStride: return "dim_stride";
+  }
+  return "";
+}
+
+::std::optional<StorageSpecifierKind> symbolizeStorageSpecifierKind(::llvm::StringRef str) {
+  return ::llvm::StringSwitch<::std::optional<StorageSpecifierKind>>(str)
+      .Case("lvl_sz", StorageSpecifierKind::LvlSize)
+      .Case("pos_mem_sz", StorageSpecifierKind::PosMemSize)
+      .Case("crd_mem_sz", StorageSpecifierKind::CrdMemSize)
+      .Case("val_mem_sz", StorageSpecifierKind::ValMemSize)
+      .Case("dim_offset", StorageSpecifierKind::DimOffset)
+      .Case("dim_stride", StorageSpecifierKind::DimStride)
+      .Default(::std::nullopt);
+}
+::std::optional<StorageSpecifierKind> symbolizeStorageSpecifierKind(uint32_t value) {
+  switch (value) {
+  case 0: return StorageSpecifierKind::LvlSize;
+  case 1: return StorageSpecifierKind::PosMemSize;
+  case 2: return StorageSpecifierKind::CrdMemSize;
+  case 3: return StorageSpecifierKind::ValMemSize;
+  case 4: return StorageSpecifierKind::DimOffset;
+  case 5: return StorageSpecifierKind::DimStride;
+  default: return ::std::nullopt;
+  }
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrEnums.h.inc

@@ -0,0 +1,177 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Enum Utility Declarations                                                  *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SparseTensorAttrDefs.td                                              *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+namespace mlir {
+namespace sparse_tensor {
+// sparse tensor sort algorithm
+enum class SparseTensorSortKind : uint32_t {
+  HybridQuickSort = 0,
+  InsertionSortStable = 1,
+  QuickSort = 2,
+  HeapSort = 3,
+};
+
+::std::optional<SparseTensorSortKind> symbolizeSparseTensorSortKind(uint32_t);
+::llvm::StringRef stringifySparseTensorSortKind(SparseTensorSortKind);
+::std::optional<SparseTensorSortKind> symbolizeSparseTensorSortKind(::llvm::StringRef);
+inline constexpr unsigned getMaxEnumValForSparseTensorSortKind() {
+  return 3;
+}
+
+
+inline ::llvm::StringRef stringifyEnum(SparseTensorSortKind enumValue) {
+  return stringifySparseTensorSortKind(enumValue);
+}
+
+template <typename EnumType>
+::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);
+
+template <>
+inline ::std::optional<SparseTensorSortKind> symbolizeEnum<SparseTensorSortKind>(::llvm::StringRef str) {
+  return symbolizeSparseTensorSortKind(str);
+}
+} // namespace sparse_tensor
+} // namespace mlir
+
+namespace mlir {
+template <typename T, typename>
+struct FieldParser;
+
+template<>
+struct FieldParser<::mlir::sparse_tensor::SparseTensorSortKind, ::mlir::sparse_tensor::SparseTensorSortKind> {
+  template <typename ParserT>
+  static FailureOr<::mlir::sparse_tensor::SparseTensorSortKind> parse(ParserT &parser) {
+    // Parse the keyword/string containing the enum.
+    std::string enumKeyword;
+    auto loc = parser.getCurrentLocation();
+    if (failed(parser.parseOptionalKeywordOrString(&enumKeyword)))
+      return parser.emitError(loc, "expected keyword for sparse tensor sort algorithm");
+
+    // Symbolize the keyword.
+    if (::std::optional<::mlir::sparse_tensor::SparseTensorSortKind> attr = ::mlir::sparse_tensor::symbolizeEnum<::mlir::sparse_tensor::SparseTensorSortKind>(enumKeyword))
+      return *attr;
+    return parser.emitError(loc, "invalid sparse tensor sort algorithm specification: ") << enumKeyword;
+  }
+};
+} // namespace mlir
+
+namespace llvm {
+inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::sparse_tensor::SparseTensorSortKind value) {
+  auto valueStr = stringifyEnum(value);
+  return p << valueStr;
+}
+} // namespace llvm
+
+namespace llvm {
+template<> struct DenseMapInfo<::mlir::sparse_tensor::SparseTensorSortKind> {
+  using StorageInfo = ::llvm::DenseMapInfo<uint32_t>;
+
+  static inline ::mlir::sparse_tensor::SparseTensorSortKind getEmptyKey() {
+    return static_cast<::mlir::sparse_tensor::SparseTensorSortKind>(StorageInfo::getEmptyKey());
+  }
+
+  static inline ::mlir::sparse_tensor::SparseTensorSortKind getTombstoneKey() {
+    return static_cast<::mlir::sparse_tensor::SparseTensorSortKind>(StorageInfo::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const ::mlir::sparse_tensor::SparseTensorSortKind &val) {
+    return StorageInfo::getHashValue(static_cast<uint32_t>(val));
+  }
+
+  static bool isEqual(const ::mlir::sparse_tensor::SparseTensorSortKind &lhs, const ::mlir::sparse_tensor::SparseTensorSortKind &rhs) {
+    return lhs == rhs;
+  }
+};
+}
+
+namespace mlir {
+namespace sparse_tensor {
+// sparse tensor storage specifier kind
+enum class StorageSpecifierKind : uint32_t {
+  LvlSize = 0,
+  PosMemSize = 1,
+  CrdMemSize = 2,
+  ValMemSize = 3,
+  DimOffset = 4,
+  DimStride = 5,
+};
+
+::std::optional<StorageSpecifierKind> symbolizeStorageSpecifierKind(uint32_t);
+::llvm::StringRef stringifyStorageSpecifierKind(StorageSpecifierKind);
+::std::optional<StorageSpecifierKind> symbolizeStorageSpecifierKind(::llvm::StringRef);
+inline constexpr unsigned getMaxEnumValForStorageSpecifierKind() {
+  return 5;
+}
+
+
+inline ::llvm::StringRef stringifyEnum(StorageSpecifierKind enumValue) {
+  return stringifyStorageSpecifierKind(enumValue);
+}
+
+template <typename EnumType>
+::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);
+
+template <>
+inline ::std::optional<StorageSpecifierKind> symbolizeEnum<StorageSpecifierKind>(::llvm::StringRef str) {
+  return symbolizeStorageSpecifierKind(str);
+}
+} // namespace sparse_tensor
+} // namespace mlir
+
+namespace mlir {
+template <typename T, typename>
+struct FieldParser;
+
+template<>
+struct FieldParser<::mlir::sparse_tensor::StorageSpecifierKind, ::mlir::sparse_tensor::StorageSpecifierKind> {
+  template <typename ParserT>
+  static FailureOr<::mlir::sparse_tensor::StorageSpecifierKind> parse(ParserT &parser) {
+    // Parse the keyword/string containing the enum.
+    std::string enumKeyword;
+    auto loc = parser.getCurrentLocation();
+    if (failed(parser.parseOptionalKeywordOrString(&enumKeyword)))
+      return parser.emitError(loc, "expected keyword for sparse tensor storage specifier kind");
+
+    // Symbolize the keyword.
+    if (::std::optional<::mlir::sparse_tensor::StorageSpecifierKind> attr = ::mlir::sparse_tensor::symbolizeEnum<::mlir::sparse_tensor::StorageSpecifierKind>(enumKeyword))
+      return *attr;
+    return parser.emitError(loc, "invalid sparse tensor storage specifier kind specification: ") << enumKeyword;
+  }
+};
+} // namespace mlir
+
+namespace llvm {
+inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::sparse_tensor::StorageSpecifierKind value) {
+  auto valueStr = stringifyEnum(value);
+  return p << valueStr;
+}
+} // namespace llvm
+
+namespace llvm {
+template<> struct DenseMapInfo<::mlir::sparse_tensor::StorageSpecifierKind> {
+  using StorageInfo = ::llvm::DenseMapInfo<uint32_t>;
+
+  static inline ::mlir::sparse_tensor::StorageSpecifierKind getEmptyKey() {
+    return static_cast<::mlir::sparse_tensor::StorageSpecifierKind>(StorageInfo::getEmptyKey());
+  }
+
+  static inline ::mlir::sparse_tensor::StorageSpecifierKind getTombstoneKey() {
+    return static_cast<::mlir::sparse_tensor::StorageSpecifierKind>(StorageInfo::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(const ::mlir::sparse_tensor::StorageSpecifierKind &val) {
+    return StorageInfo::getHashValue(static_cast<uint32_t>(val));
+  }
+
+  static bool isEqual(const ::mlir::sparse_tensor::StorageSpecifierKind &lhs, const ::mlir::sparse_tensor::StorageSpecifierKind &rhs) {
+    return lhs == rhs;
+  }
+};
+}
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOpsDialect.cpp.inc

@@ -0,0 +1,23 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Dialect Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SparseTensorOps.td                                                   *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorDialect)
+namespace mlir {
+namespace sparse_tensor {
+
+SparseTensorDialect::SparseTensorDialect(::mlir::MLIRContext *context)
+    : ::mlir::Dialect(getDialectNamespace(), context, ::mlir::TypeID::get<SparseTensorDialect>()) {
+  
+  initialize();
+}
+
+SparseTensorDialect::~SparseTensorDialect() = default;
+
+} // namespace sparse_tensor
+} // namespace mlir

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOpsDialect.h.inc

@@ -0,0 +1,41 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* Dialect Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|* From: SparseTensorOps.td                                                   *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+namespace mlir {
+namespace sparse_tensor {
+
+class SparseTensorDialect : public ::mlir::Dialect {
+  explicit SparseTensorDialect(::mlir::MLIRContext *context);
+
+  void initialize();
+  friend class ::mlir::MLIRContext;
+public:
+  ~SparseTensorDialect() override;
+  static constexpr ::llvm::StringLiteral getDialectNamespace() {
+    return ::llvm::StringLiteral("sparse_tensor");
+  }
+
+  /// Parse an attribute registered to this dialect.
+  ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
+                                   ::mlir::Type type) const override;
+
+  /// Print an attribute registered to this dialect.
+  void printAttribute(::mlir::Attribute attr,
+                      ::mlir::DialectAsmPrinter &os) const override;
+
+  /// Parse a type registered to this dialect.
+  ::mlir::Type parseType(::mlir::DialectAsmParser &parser) const override;
+
+  /// Print a type registered to this dialect.
+  void printType(::mlir::Type type,
+                 ::mlir::DialectAsmPrinter &os) const override;
+};
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::SparseTensorDialect)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorStorageLayout.h

@@ -0,0 +1,183 @@
+//===- SparseTensorStorageLayout.h ------------------------------*- 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 header file defines utilities for the sparse memory layout.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORSTORAGELAYOUT_H_
+#define MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORSTORAGELAYOUT_H_
+
+#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorType.h"
+
+namespace mlir {
+namespace sparse_tensor {
+
+///===----------------------------------------------------------------------===//
+/// The sparse tensor storage scheme for a tensor is organized as a single
+/// compound type with the following fields. Note that every memref with ? size
+/// actually behaves as a "vector", i.e. the stored size is the capacity and the
+/// used size resides in the storage_specifier struct.
+///
+/// struct {
+///   ; per-level l:
+///   ;  if dense:
+///        <nothing>
+///   ;  if compresed:
+///        memref<? x pos>  positions-l   ; positions for sparse level l
+///        memref<? x crd>  coordinates-l ; coordinates for sparse level l
+///   ;  if singleton:
+///        memref<? x crd>  coordinates-l ; coordinates for singleton level l
+///
+///   memref<? x eltType> values        ; values
+///
+///   struct sparse_tensor.storage_specifier {
+///     array<rank x int> lvlSizes    ; sizes/cardinalities for each level
+///     array<n x int> memSizes;      ; sizes/lengths for each data memref
+///   }
+/// };
+///
+/// In addition, for a "trailing COO region", defined as a compressed level
+/// followed by one or more singleton levels, the default SOA storage that
+/// is inherent to the TACO format is optimized into an AOS storage where
+/// all coordinates of a stored element appear consecutively.  In such cases,
+/// a special operation (sparse_tensor.coordinates_buffer) must be used to
+/// access the AOS coordinates array. In the code below, the method
+/// `getCOOStart` is used to find the start of the "trailing COO region".
+///
+/// If the sparse tensor is a slice (produced by `tensor.extract_slice`
+/// operation), instead of allocating a new sparse tensor for it, it reuses the
+/// same sets of MemRefs but attaching a additional set of slicing-metadata for
+/// per-dimension slice offset and stride.
+///
+/// Examples.
+///
+/// #CSR storage of 2-dim matrix yields
+///   memref<?xindex>                           ; positions-1
+///   memref<?xindex>                           ; coordinates-1
+///   memref<?xf64>                             ; values
+///   struct<(array<2 x i64>, array<3 x i64>)>) ; lvl0, lvl1, 3xsizes
+///
+/// #COO storage of 2-dim matrix yields
+///   memref<?xindex>,                          ; positions-0, essentially
+///   [0,sz] memref<?xindex>                           ; AOS coordinates storage
+///   memref<?xf64>                             ; values
+///   struct<(array<2 x i64>, array<3 x i64>)>) ; lvl0, lvl1, 3xsizes
+///
+/// Slice on #COO storage of 2-dim matrix yields
+///   ;; Inherited from the original sparse tensors
+///   memref<?xindex>,                          ; positions-0, essentially
+///   [0,sz] memref<?xindex>                           ; AOS coordinates storage
+///   memref<?xf64>                             ; values
+///   struct<(array<2 x i64>, array<3 x i64>,   ; lvl0, lvl1, 3xsizes
+///   ;; Extra slicing-metadata
+///           array<2 x i64>, array<2 x i64>)>) ; dim offset, dim stride.
+///
+///===----------------------------------------------------------------------===//
+
+enum class SparseTensorFieldKind : uint32_t {
+  StorageSpec = 0,
+  PosMemRef = static_cast<uint32_t>(StorageSpecifierKind::PosMemSize),
+  CrdMemRef = static_cast<uint32_t>(StorageSpecifierKind::CrdMemSize),
+  ValMemRef = static_cast<uint32_t>(StorageSpecifierKind::ValMemSize)
+};
+
+inline StorageSpecifierKind toSpecifierKind(SparseTensorFieldKind kind) {
+  assert(kind != SparseTensorFieldKind::StorageSpec);
+  return static_cast<StorageSpecifierKind>(kind);
+}
+
+inline SparseTensorFieldKind toFieldKind(StorageSpecifierKind kind) {
+  assert(kind != StorageSpecifierKind::LvlSize);
+  return static_cast<SparseTensorFieldKind>(kind);
+}
+
+/// The type of field indices.  This alias is to help code be more
+/// self-documenting; unfortunately it is not type-checked, so it only
+/// provides documentation rather than doing anything to prevent mixups.
+using FieldIndex = unsigned;
+
+/// Provides methods to access fields of a sparse tensor with the given
+/// encoding.
+class StorageLayout {
+public:
+  // TODO: Functions/methods marked with [NUMFIELDS] should use
+  // `FieldIndex` for their return type, via the same reasoning for why
+  // `Dimension`/`Level` are used both for identifiers and ranks.
+  explicit StorageLayout(const SparseTensorType &stt)
+      : StorageLayout(stt.getEncoding()) {}
+  explicit StorageLayout(SparseTensorEncodingAttr enc) : enc(enc) {
+    assert(enc);
+  }
+
+  /// For each field that will be allocated for the given sparse tensor
+  /// encoding, calls the callback with the corresponding field index,
+  /// field kind, level, and level-type (the last two are only for level
+  /// memrefs).  The field index always starts with zero and increments
+  /// by one between each callback invocation.  Ideally, all other methods
+  /// should rely on this function to query a sparse tensor fields instead
+  /// of relying on ad-hoc index computation.
+  void foreachField(
+      llvm::function_ref<bool(
+          FieldIndex /*fieldIdx*/, SparseTensorFieldKind /*fieldKind*/,
+          Level /*lvl (if applicable)*/, DimLevelType /*DLT (if applicable)*/)>)
+      const;
+
+  /// Gets the field index for required field.
+  FieldIndex getMemRefFieldIndex(SparseTensorFieldKind kind,
+                                 std::optional<Level> lvl) const {
+    return getFieldIndexAndStride(kind, lvl).first;
+  }
+
+  /// Gets the total number of fields for the given sparse tensor encoding.
+  unsigned getNumFields() const;
+
+  /// Gets the total number of data fields (coordinate arrays, position
+  /// arrays, and a value array) for the given sparse tensor encoding.
+  unsigned getNumDataFields() const;
+
+  std::pair<FieldIndex, unsigned>
+  getFieldIndexAndStride(SparseTensorFieldKind kind,
+                         std::optional<Level> lvl) const;
+
+private:
+  const SparseTensorEncodingAttr enc;
+};
+
+//
+// Wrapper functions to invoke StorageLayout-related method.
+//
+
+// See note [NUMFIELDS].
+inline unsigned getNumFieldsFromEncoding(SparseTensorEncodingAttr enc) {
+  return StorageLayout(enc).getNumFields();
+}
+
+// See note [NUMFIELDS].
+inline unsigned getNumDataFieldsFromEncoding(SparseTensorEncodingAttr enc) {
+  return StorageLayout(enc).getNumDataFields();
+}
+
+inline void foreachFieldInSparseTensor(
+    SparseTensorEncodingAttr enc,
+    llvm::function_ref<bool(FieldIndex, SparseTensorFieldKind, Level,
+                            DimLevelType)>
+        callback) {
+  return StorageLayout(enc).foreachField(callback);
+}
+
+void foreachFieldAndTypeInSparseTensor(
+    SparseTensorType,
+    llvm::function_ref<bool(Type, FieldIndex, SparseTensorFieldKind, Level,
+                            DimLevelType)>);
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORSTORAGELAYOUT_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorType.h

@@ -0,0 +1,325 @@
+//===- SparseTensorType.h - Wrapper around RankedTensorType -----*- 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 header defines the `SparseTensorType` wrapper class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORTYPE_H_
+#define MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORTYPE_H_
+
+#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
+
+namespace mlir {
+namespace sparse_tensor {
+
+//===----------------------------------------------------------------------===//
+/// A wrapper around `RankedTensorType`, which has three goals:
+///
+/// (1) To provide a uniform API for querying aspects of sparse-tensor
+/// types; in particular, to make the "dimension" vs "level" distinction
+/// overt (i.e., explicit everywhere).  Thus, throughout the sparse-compiler
+/// this class should be preferred over using `RankedTensorType` or
+/// `ShapedType` directly, since the methods of the latter do not make
+/// the "dimension" vs "level" distinction overt.
+///
+/// (2) To provide a uniform abstraction over both sparse-tensor
+/// types (i.e., `RankedTensorType` with `SparseTensorEncodingAttr`)
+/// and dense-tensor types (i.e., `RankedTensorType` without an encoding).
+/// That is, we want to manipulate dense-tensor types using the same API
+/// that we use for manipulating sparse-tensor types; both to keep the
+/// "dimension" vs "level" distinction overt, and to avoid needing to
+/// handle certain cases specially in the sparse-compiler.
+///
+/// (3) To provide uniform handling of "defaults".  In particular
+/// this means that dense-tensors should always return the same answers
+/// as sparse-tensors with a default encoding.  But it additionally means
+/// that the answers should be normalized, so that there's no way to
+/// distinguish between non-provided data (which is filled in by default)
+/// vs explicitly-provided data which equals the defaults.
+///
+class SparseTensorType {
+public:
+  // We memoize `lvlRank`, `dimToLvl`, and `lvlToDim` to avoid repeating
+  // the conditionals throughout the rest of the class.
+  SparseTensorType(RankedTensorType rtp)
+      : rtp(rtp), enc(getSparseTensorEncoding(rtp)),
+        lvlRank(enc ? enc.getLvlRank() : getDimRank()),
+        dimToLvl(enc.isIdentity() ? AffineMap() : enc.getDimToLvl()),
+        lvlToDim(enc.isIdentity() ? AffineMap() : enc.getLvlToDim()) {
+    assert(rtp && "got null RankedTensorType");
+    assert((!isIdentity() || getDimRank() == lvlRank) && "Rank mismatch");
+  }
+
+  SparseTensorType(ShapedType stp, SparseTensorEncodingAttr enc)
+      : SparseTensorType(
+            RankedTensorType::get(stp.getShape(), stp.getElementType(), enc)) {}
+
+  // Copy-assignment would be implicitly deleted (because our fields
+  // are const), so we explicitly delete it for clarity.
+  SparseTensorType &operator=(const SparseTensorType &) = delete;
+  // So we must explicitly define the copy-ctor to silence -Wdeprecated-copy.
+  SparseTensorType(const SparseTensorType &) = default;
+
+  //
+  // Factory methods.
+  //
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by the given encoding.
+  SparseTensorType withEncoding(SparseTensorEncodingAttr newEnc) const {
+    return SparseTensorType(rtp, newEnc);
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withDimToLvl(dimToLvl)`.
+  SparseTensorType withDimToLvl(AffineMap dimToLvl) const {
+    return withEncoding(enc.withDimToLvl(dimToLvl));
+  }
+
+  SparseTensorType withDimToLvl(SparseTensorEncodingAttr dimToLvlEnc) const {
+    return withEncoding(enc.withDimToLvl(dimToLvlEnc));
+  }
+
+  SparseTensorType withDimToLvl(const SparseTensorType &dimToLvlSTT) const {
+    return withDimToLvl(dimToLvlSTT.getEncoding());
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withoutDimToLvl()`.
+  SparseTensorType withoutDimToLvl() const {
+    return withEncoding(enc.withoutDimToLvl());
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withBitWidths(posWidth, crdWidth)`.
+  SparseTensorType withBitWidths(unsigned posWidth, unsigned crdWidth) const {
+    return withEncoding(enc.withBitWidths(posWidth, crdWidth));
+  }
+
+  /// Constructs a new `SparseTensorType` with the same dimension-shape
+  /// and element type, but with the encoding replaced by
+  /// `getEncoding().withoutBitWidths()`.
+  SparseTensorType withoutBitWidths() const {
+    return withEncoding(enc.withoutBitWidths());
+  }
+
+  SparseTensorType
+  withDimSlices(ArrayRef<SparseTensorDimSliceAttr> dimSlices) const {
+    return withEncoding(enc.withDimSlices(dimSlices));
+  }
+
+  SparseTensorType withoutDimSlices() const {
+    return withEncoding(enc.withoutDimSlices());
+  }
+
+  //
+  // Other methods.
+  //
+
+  /// Allow implicit conversion to `RankedTensorType`, `ShapedType`,
+  /// and `Type`.  These are implicit to help alleviate the impedance
+  /// mismatch for code that has not been converted to use `SparseTensorType`
+  /// directly.  Once more uses have been converted to `SparseTensorType`,
+  /// we may want to make these explicit instead.
+  ///
+  /// WARNING: This user-defined-conversion method causes overload
+  /// ambiguity whenever passing a `SparseTensorType` directly to a
+  /// function which is overloaded to accept either `Type` or `TypeRange`.
+  /// In particular, this includes `RewriterBase::replaceOpWithNewOp<OpTy>`
+  /// and `OpBuilder::create<OpTy>` whenever the `OpTy::build` is overloaded
+  /// thus.  This happens because the `TypeRange<T>(T&&)` ctor is implicit
+  /// as well, and there's no SFINAE we can add to this method that would
+  /// block subsequent application of that ctor.  The only way to fix the
+  /// overload ambiguity is to avoid *implicit* conversion at the callsite:
+  /// e.g., by using `static_cast` to make the conversion explicit, by
+  /// assigning the `SparseTensorType` to a temporary variable of the
+  /// desired type, etc.
+  //
+  // NOTE: We implement this as a single templated user-defined-conversion
+  // function to avoid ambiguity problems when the desired result is `Type`
+  // (since both `RankedTensorType` and `ShapedType` can be implicitly
+  // converted to `Type`).
+  template <typename T, typename = std::enable_if_t<
+                            std::is_convertible_v<RankedTensorType, T>>>
+  /*implicit*/ operator T() const {
+    return rtp;
+  }
+
+  /// Explicitly convert to `RankedTensorType`.  This method is
+  /// a convenience for resolving overload-ambiguity issues with
+  /// implicit conversion.
+  RankedTensorType getRankedTensorType() const { return rtp; }
+
+  bool operator==(const SparseTensorType &other) const {
+    // All other fields are derived from `rtp` and therefore don't need
+    // to be checked.
+    return rtp == other.rtp;
+  }
+
+  bool operator!=(const SparseTensorType &other) const {
+    return !(*this == other);
+  }
+
+  MLIRContext *getContext() const { return rtp.getContext(); }
+
+  Type getElementType() const { return rtp.getElementType(); }
+
+  /// Returns the encoding (or the null-attribute for dense-tensors).
+  SparseTensorEncodingAttr getEncoding() const { return enc; }
+
+  /// Returns true for tensors which have an encoding, and false for
+  /// those which do not.  Therefore tensors with an all-dense encoding
+  /// return true.
+  bool hasEncoding() const { return static_cast<bool>(enc); }
+
+  /// Returns true for tensors where every level is dense.
+  /// (This is always true for dense-tensors.)
+  bool isAllDense() const { return enc.isAllDense(); }
+
+  /// Returns true for tensors where every level is ordered.
+  /// (This is always true for dense-tensors.)
+  bool isAllOrdered() const { return enc.isAllOrdered(); }
+
+  /// Returns true if the dimToLvl mapping is the identity.
+  /// (This is always true for dense-tensors.)
+  bool isIdentity() const { return !dimToLvl; }
+
+  /// Returns true if the dimToLvl mapping is a permutation.
+  /// (This is always true for dense-tensors.)
+  bool isPermutation() const { return enc.isPermutation(); }
+
+  /// Returns the dimToLvl mapping (or the null-map for the identity).
+  /// If you intend to compare the results of this method for equality,
+  /// see `hasSameDimToLvl` instead.
+  AffineMap getDimToLvl() const { return dimToLvl; }
+
+  /// Returns the lvlToDiml mapping (or the null-map for the identity).
+  AffineMap getLvlToDim() const { return lvlToDim; }
+
+  /// Returns the dimToLvl mapping, where the identity map is expanded out
+  /// into a full `AffineMap`.  This method is provided as a convenience,
+  /// but for most purposes other methods (`isIdentity`, `getDimToLvl`,
+  /// etc) will be more helpful.
+  AffineMap getExpandedDimToLvl() const {
+    return dimToLvl
+               ? dimToLvl
+               : AffineMap::getMultiDimIdentityMap(getDimRank(), getContext());
+  }
+
+  /// Returns true iff the two types have the same mapping.  This method
+  /// takes care to handle identity maps properly, so it should be preferred
+  /// over using `getDimToLvl` followed by `AffineMap::operator==`.
+  bool hasSameDimToLvl(const SparseTensorType &other) const {
+    // If the maps are the identity, then we need to check the rank
+    // to be sure they're the same size identity.  (And since identity
+    // means dimRank==lvlRank, we use lvlRank as a minor optimization.)
+    return isIdentity() ? (other.isIdentity() && lvlRank == other.lvlRank)
+                        : (dimToLvl == other.dimToLvl);
+  }
+
+  /// Returns the dimension-rank.
+  Dimension getDimRank() const { return rtp.getRank(); }
+
+  /// Returns the level-rank.
+  Level getLvlRank() const { return lvlRank; }
+
+  /// Returns the dimension-shape.
+  ArrayRef<DynSize> getDimShape() const { return rtp.getShape(); }
+
+  /// Safely looks up the requested dimension-DynSize.  If you intend
+  /// to check the result with `ShapedType::isDynamic`, then see the
+  /// `getStaticDimSize` method instead.
+  DynSize getDynamicDimSize(Dimension d) const {
+    assert(d < getDimRank() && "Dimension is out of bounds");
+    return getDimShape()[d];
+  }
+
+  /// Safely looks up the requested dimension-size, mapping dynamic
+  /// sizes to `std::nullopt`.
+  std::optional<StaticSize> getStaticDimSize(Dimension d) const {
+    const DynSize sh = getDynamicDimSize(d);
+    return ShapedType::isDynamic(sh) ? std::nullopt
+                                     : std::optional<StaticSize>(sh);
+  }
+
+  /// Returns true if no dimension has dynamic size.
+  bool hasStaticDimShape() const { return rtp.hasStaticShape(); }
+
+  /// Returns true if any dimension has dynamic size.
+  bool hasDynamicDimShape() const { return !hasStaticDimShape(); }
+
+  /// Returns true if the given dimension has dynamic size.  If you
+  /// intend to call `getDynamicDimSize` based on the result, then see
+  /// the `getStaticDimSize` method instead.
+  bool isDynamicDim(Dimension d) const {
+    // We don't use `rtp.isDynamicDim(d)` because we want the
+    // OOB error message to be consistent with `getDynamicDimSize`.
+    return ShapedType::isDynamic(getDynamicDimSize(d));
+  }
+
+  /// Returns the number of dimensions which have dynamic sizes.
+  /// The return type is `int64_t` to maintain consistency with
+  /// `ShapedType::Trait<T>::getNumDynamicDims`.
+  int64_t getNumDynamicDims() const { return rtp.getNumDynamicDims(); }
+
+  DimLevelType getLvlType(Level l) const {
+    // This OOB check is for dense-tensors, since this class knows
+    // their lvlRank (whereas STEA::getLvlType will/can only check
+    // OOB for sparse-tensors).
+    assert(l < lvlRank && "Level out of bounds");
+    return enc.getLvlType(l);
+  }
+
+  // We can't just delegate these, since we want to use this class's
+  // `getLvlType` method instead of STEA's.
+  bool isDenseLvl(Level l) const { return isDenseDLT(getLvlType(l)); }
+  bool isCompressedLvl(Level l) const { return isCompressedDLT(getLvlType(l)); }
+  bool isSingletonLvl(Level l) const { return isSingletonDLT(getLvlType(l)); }
+  bool isOrderedLvl(Level l) const { return isOrderedDLT(getLvlType(l)); }
+  bool isUniqueLvl(Level l) const { return isUniqueDLT(getLvlType(l)); }
+
+  /// Returns the coordinate-overhead bitwidth, defaulting to zero.
+  unsigned getCrdWidth() const { return enc ? enc.getCrdWidth() : 0; }
+
+  /// Returns the position-overhead bitwidth, defaulting to zero.
+  unsigned getPosWidth() const { return enc ? enc.getPosWidth() : 0; }
+
+  /// Returns the coordinate-overhead MLIR type, defaulting to `IndexType`.
+  Type getCrdType() const {
+    return detail::getIntegerOrIndexType(getContext(), getCrdWidth());
+  }
+
+  /// Returns the position-overhead MLIR type, defaulting to `IndexType`.
+  Type getPosType() const {
+    return detail::getIntegerOrIndexType(getContext(), getPosWidth());
+  }
+
+private:
+  // These two must be const, to ensure coherence of the memoized fields.
+  const RankedTensorType rtp;
+  const SparseTensorEncodingAttr enc;
+  // Memoized to avoid frequent redundant conditionals.
+  const Level lvlRank;
+  const AffineMap dimToLvl;
+  const AffineMap lvlToDim;
+};
+
+/// Convenience method to abbreviate wrapping `getRankedTensorType`.
+template <typename T>
+inline SparseTensorType getSparseTensorType(T t) {
+  return SparseTensorType(getRankedTensorType(t));
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_IR_SPARSETENSORTYPE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorTypes.cpp.inc

@@ -0,0 +1,141 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* TypeDef Definitions                                                        *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_TYPEDEF_LIST
+#undef GET_TYPEDEF_LIST
+
+::mlir::sparse_tensor::StorageSpecifierType
+
+#endif  // GET_TYPEDEF_LIST
+
+#ifdef GET_TYPEDEF_CLASSES
+#undef GET_TYPEDEF_CLASSES
+
+static ::mlir::OptionalParseResult generatedTypeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type &value) {
+  return ::mlir::AsmParser::KeywordSwitch<::mlir::OptionalParseResult>(parser)
+    .Case(::mlir::sparse_tensor::StorageSpecifierType::getMnemonic(), [&](llvm::StringRef, llvm::SMLoc) {
+      value = ::mlir::sparse_tensor::StorageSpecifierType::parse(parser);
+      return ::mlir::success(!!value);
+    })
+    .Default([&](llvm::StringRef keyword, llvm::SMLoc) {
+      *mnemonic = keyword;
+      return std::nullopt;
+    });
+}
+
+static ::mlir::LogicalResult generatedTypePrinter(::mlir::Type def, ::mlir::AsmPrinter &printer) {
+  return ::llvm::TypeSwitch<::mlir::Type, ::mlir::LogicalResult>(def)    .Case<::mlir::sparse_tensor::StorageSpecifierType>([&](auto t) {
+      printer << ::mlir::sparse_tensor::StorageSpecifierType::getMnemonic();
+t.print(printer);
+      return ::mlir::success();
+    })
+    .Default([](auto) { return ::mlir::failure(); });
+}
+
+namespace mlir {
+namespace sparse_tensor {
+namespace detail {
+struct StorageSpecifierTypeStorage : public ::mlir::TypeStorage {
+  using KeyTy = std::tuple<::mlir::sparse_tensor::SparseTensorEncodingAttr>;
+  StorageSpecifierTypeStorage(::mlir::sparse_tensor::SparseTensorEncodingAttr encoding) : encoding(std::move(encoding)) {}
+
+  KeyTy getAsKey() const {
+    return KeyTy(encoding);
+  }
+
+  bool operator==(const KeyTy &tblgenKey) const {
+    return (encoding == std::get<0>(tblgenKey));
+  }
+
+  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
+    return ::llvm::hash_combine(std::get<0>(tblgenKey));
+  }
+
+  static StorageSpecifierTypeStorage *construct(::mlir::TypeStorageAllocator &allocator, KeyTy &&tblgenKey) {
+    auto encoding = std::move(std::get<0>(tblgenKey));
+    return new (allocator.allocate<StorageSpecifierTypeStorage>()) StorageSpecifierTypeStorage(std::move(encoding));
+  }
+
+  ::mlir::sparse_tensor::SparseTensorEncodingAttr encoding;
+};
+} // namespace detail
+StorageSpecifierType StorageSpecifierType::get(SparseTensorEncodingAttr encoding) {
+  return get(encoding.getContext(), encoding);
+}
+
+StorageSpecifierType StorageSpecifierType::get(Type type) {
+  return get(getSparseTensorEncoding(type));
+}
+
+StorageSpecifierType StorageSpecifierType::get(Value tensor) {
+  return get(tensor.getType());
+}
+
+::mlir::Type StorageSpecifierType::parse(::mlir::AsmParser &odsParser) {
+  ::mlir::Builder odsBuilder(odsParser.getContext());
+  ::llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
+  (void) odsLoc;
+  ::mlir::FailureOr<::mlir::sparse_tensor::SparseTensorEncodingAttr> _result_encoding;
+  // Parse literal '<'
+  if (odsParser.parseLess()) return {};
+
+  // Parse variable 'encoding'
+  _result_encoding = ::mlir::FieldParser<::mlir::sparse_tensor::SparseTensorEncodingAttr>::parse(odsParser);
+  if (::mlir::failed(_result_encoding)) {
+    odsParser.emitError(odsParser.getCurrentLocation(), "failed to parse SparseTensor_StorageSpecifier parameter 'encoding' which is to be a `::mlir::sparse_tensor::SparseTensorEncodingAttr`");
+    return {};
+  }
+  // Parse literal '>'
+  if (odsParser.parseGreater()) return {};
+  assert(::mlir::succeeded(_result_encoding));
+  return StorageSpecifierType::get(odsParser.getContext(),
+      ::mlir::sparse_tensor::SparseTensorEncodingAttr(::llvm::cast<::mlir::sparse_tensor::SparseTensorEncodingAttr>((*_result_encoding))));
+}
+
+void StorageSpecifierType::print(::mlir::AsmPrinter &odsPrinter) const {
+  ::mlir::Builder odsBuilder(getContext());
+  odsPrinter << "<";
+  odsPrinter << getEncoding();
+  odsPrinter << ">";
+}
+
+::mlir::sparse_tensor::SparseTensorEncodingAttr StorageSpecifierType::getEncoding() const {
+  return getImpl()->encoding;
+}
+
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::StorageSpecifierType)
+namespace mlir {
+namespace sparse_tensor {
+
+/// Parse a type registered to this dialect.
+::mlir::Type SparseTensorDialect::parseType(::mlir::DialectAsmParser &parser) const {
+  ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  ::llvm::StringRef mnemonic;
+  ::mlir::Type genType;
+  auto parseResult = generatedTypeParser(parser, &mnemonic, genType);
+  if (parseResult.has_value())
+    return genType;
+  
+  parser.emitError(typeLoc) << "unknown  type `"
+      << mnemonic << "` in dialect `" << getNamespace() << "`";
+  return {};
+}
+/// Print a type registered to this dialect.
+void SparseTensorDialect::printType(::mlir::Type type,
+                    ::mlir::DialectAsmPrinter &printer) const {
+  if (::mlir::succeeded(generatedTypePrinter(type, printer)))
+    return;
+  
+}
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif  // GET_TYPEDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorTypes.h.inc

@@ -0,0 +1,43 @@
+/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
+|*                                                                            *|
+|* TypeDef Declarations                                                       *|
+|*                                                                            *|
+|* Automatically generated file, do not edit!                                 *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifdef GET_TYPEDEF_CLASSES
+#undef GET_TYPEDEF_CLASSES
+
+
+namespace mlir {
+class AsmParser;
+class AsmPrinter;
+} // namespace mlir
+namespace mlir {
+namespace sparse_tensor {
+class StorageSpecifierType;
+namespace detail {
+struct StorageSpecifierTypeStorage;
+} // namespace detail
+class StorageSpecifierType : public ::mlir::Type::TypeBase<StorageSpecifierType, ::mlir::Type, detail::StorageSpecifierTypeStorage> {
+public:
+  using Base::Base;
+  static StorageSpecifierType get(::mlir::MLIRContext *context, SparseTensorEncodingAttr encoding);
+  static StorageSpecifierType get(SparseTensorEncodingAttr encoding);
+  static StorageSpecifierType get(Type type);
+  static StorageSpecifierType get(Value tensor);
+  static constexpr ::llvm::StringLiteral getMnemonic() {
+    return {"storage_specifier"};
+  }
+
+  static ::mlir::Type parse(::mlir::AsmParser &odsParser);
+  void print(::mlir::AsmPrinter &odsPrinter) const;
+  ::mlir::sparse_tensor::SparseTensorEncodingAttr getEncoding() const;
+};
+} // namespace sparse_tensor
+} // namespace mlir
+MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::sparse_tensor::StorageSpecifierType)
+
+#endif  // GET_TYPEDEF_CLASSES
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/Transforms/BufferizableOpInterfaceImpl.h

@@ -0,0 +1,20 @@
+//===- BufferizableOpInterfaceImpl.h - Impl. of BufferizableOpInterface ---===//
+//
+// 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_SPARSETENSOR_TRANSFORMS_BUFFERIZABLEOPINTERFACEIMPL_H_
+#define MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_BUFFERIZABLEOPINTERFACEIMPL_H_
+
+namespace mlir {
+class DialectRegistry;
+
+namespace sparse_tensor {
+void registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry);
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_BUFFERIZABLEOPINTERFACEIMPL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.capi.cpp.inc

@@ -0,0 +1,96 @@
+/* Autogenerated by mlir-tblgen; don't manually edit. */
+//===----------------------------------------------------------------------===//
+// SparseTensor Group Registration
+//===----------------------------------------------------------------------===//
+
+void mlirRegisterSparseTensorPasses(void) {
+  registerSparseTensorPasses();
+}
+
+MlirPass mlirCreateSparseTensorPostSparsificationRewrite(void) {
+  return wrap(mlir::createPostSparsificationRewritePass().release());
+}
+void mlirRegisterSparseTensorPostSparsificationRewrite(void) {
+  registerPostSparsificationRewrite();
+}
+
+
+MlirPass mlirCreateSparseTensorPreSparsificationRewrite(void) {
+  return wrap(mlir::createPreSparsificationRewritePass().release());
+}
+void mlirRegisterSparseTensorPreSparsificationRewrite(void) {
+  registerPreSparsificationRewrite();
+}
+
+
+MlirPass mlirCreateSparseTensorSparseBufferRewrite(void) {
+  return wrap(mlir::createSparseBufferRewritePass().release());
+}
+void mlirRegisterSparseTensorSparseBufferRewrite(void) {
+  registerSparseBufferRewrite();
+}
+
+
+MlirPass mlirCreateSparseTensorSparseGPUCodegen(void) {
+  return wrap(mlir::createSparseGPUCodegenPass().release());
+}
+void mlirRegisterSparseTensorSparseGPUCodegen(void) {
+  registerSparseGPUCodegen();
+}
+
+
+MlirPass mlirCreateSparseTensorSparseTensorCodegen(void) {
+  return wrap(mlir::createSparseTensorCodegenPass().release());
+}
+void mlirRegisterSparseTensorSparseTensorCodegen(void) {
+  registerSparseTensorCodegen();
+}
+
+
+MlirPass mlirCreateSparseTensorSparseTensorConversionPass(void) {
+  return wrap(mlir::createSparseTensorConversionPass().release());
+}
+void mlirRegisterSparseTensorSparseTensorConversionPass(void) {
+  registerSparseTensorConversionPass();
+}
+
+
+MlirPass mlirCreateSparseTensorSparseVectorization(void) {
+  return wrap(mlir::createSparseVectorizationPass().release());
+}
+void mlirRegisterSparseTensorSparseVectorization(void) {
+  registerSparseVectorization();
+}
+
+
+MlirPass mlirCreateSparseTensorSparsificationAndBufferization(void) {
+  return wrap(mlir::createSparsificationAndBufferizationPass().release());
+}
+void mlirRegisterSparseTensorSparsificationAndBufferization(void) {
+  registerSparsificationAndBufferization();
+}
+
+
+MlirPass mlirCreateSparseTensorSparsificationPass(void) {
+  return wrap(mlir::createSparsificationPass().release());
+}
+void mlirRegisterSparseTensorSparsificationPass(void) {
+  registerSparsificationPass();
+}
+
+
+MlirPass mlirCreateSparseTensorStageSparseOperations(void) {
+  return wrap(mlir::createStageSparseOperationsPass().release());
+}
+void mlirRegisterSparseTensorStageSparseOperations(void) {
+  registerStageSparseOperations();
+}
+
+
+MlirPass mlirCreateSparseTensorStorageSpecifierToLLVM(void) {
+  return wrap(mlir::createStorageSpecifierToLLVMPass().release());
+}
+void mlirRegisterSparseTensorStorageSpecifierToLLVM(void) {
+  registerStorageSpecifierToLLVM();
+}
+

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.capi.h.inc

@@ -0,0 +1,72 @@
+
+/* Autogenerated by mlir-tblgen; don't manually edit. */
+
+#include "mlir-c/Pass.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Registration for the entire group
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorPasses(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorPostSparsificationRewrite(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorPostSparsificationRewrite(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorPreSparsificationRewrite(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorPreSparsificationRewrite(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparseBufferRewrite(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparseBufferRewrite(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparseGPUCodegen(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparseGPUCodegen(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparseTensorCodegen(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparseTensorCodegen(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparseTensorConversionPass(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparseTensorConversionPass(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparseVectorization(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparseVectorization(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparsificationAndBufferization(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparsificationAndBufferization(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorSparsificationPass(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorSparsificationPass(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorStageSparseOperations(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorStageSparseOperations(void);
+
+
+/* Create SparseTensor Pass. */
+MLIR_CAPI_EXPORTED MlirPass mlirCreateSparseTensorStorageSpecifierToLLVM(void);
+MLIR_CAPI_EXPORTED void mlirRegisterSparseTensorStorageSpecifierToLLVM(void);
+
+
+
+#ifdef __cplusplus
+}
+#endif

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.h

@@ -0,0 +1,253 @@
+//===- Passes.h - Sparse tensor pass entry points ---------------*- 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 header file defines prototypes of all sparse tensor passes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES_H_
+#define MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES_H_
+
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+//===----------------------------------------------------------------------===//
+// Include the generated pass header (which needs some early definitions).
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+
+namespace bufferization {
+struct OneShotBufferizationOptions;
+} // namespace bufferization
+
+/// Defines a parallelization strategy. Any independent loop is a candidate
+/// for parallelization. The loop is made parallel if (1) allowed by the
+/// strategy (e.g., AnyStorageOuterLoop considers either a dense or sparse
+/// outermost loop only), and (2) the generated code is an actual for-loop
+/// (and not a co-iterating while-loop).
+enum class SparseParallelizationStrategy {
+  kNone,
+  kDenseOuterLoop,
+  kAnyStorageOuterLoop,
+  kDenseAnyLoop,
+  kAnyStorageAnyLoop
+};
+
+/// Defines data movement strategy between host and device for GPU.
+// TODO : Zero copy is disabled due to correctness bugs (tracker #64316)
+enum class GPUDataTransferStrategy { kRegularDMA, kZeroCopy, kPinnedDMA };
+
+#define GEN_PASS_DECL
+#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
+
+//===----------------------------------------------------------------------===//
+// The PreSparsificationRewriting pass.
+//===----------------------------------------------------------------------===//
+
+void populatePreSparsificationRewriting(RewritePatternSet &patterns);
+
+std::unique_ptr<Pass> createPreSparsificationRewritePass();
+
+//===----------------------------------------------------------------------===//
+// The Sparsification pass.
+//===----------------------------------------------------------------------===//
+
+/// Options for the Sparsification pass.
+struct SparsificationOptions {
+  SparsificationOptions(SparseParallelizationStrategy p,
+                        GPUDataTransferStrategy t, bool idxReduc,
+                        bool gpuLibgen, bool enableRT)
+      : parallelizationStrategy(p), gpuDataTransferStrategy(t),
+        enableIndexReduction(idxReduc), enableGPULibgen(gpuLibgen),
+        enableRuntimeLibrary(enableRT) {}
+  SparsificationOptions()
+      : SparsificationOptions(SparseParallelizationStrategy::kNone,
+                              GPUDataTransferStrategy::kRegularDMA, false,
+                              false, true) {}
+  SparseParallelizationStrategy parallelizationStrategy;
+  GPUDataTransferStrategy gpuDataTransferStrategy;
+  bool enableIndexReduction;
+  bool enableGPULibgen;
+  bool enableRuntimeLibrary;
+};
+
+/// Sets up sparsification rewriting rules with the given options.
+void populateSparsificationPatterns(
+    RewritePatternSet &patterns,
+    const SparsificationOptions &options = SparsificationOptions());
+
+std::unique_ptr<Pass> createSparsificationPass();
+std::unique_ptr<Pass>
+createSparsificationPass(const SparsificationOptions &options);
+
+//===----------------------------------------------------------------------===//
+// The StageSparseOperations pass.
+//===----------------------------------------------------------------------===//
+
+/// Sets up StageSparseOperation rewriting rules.
+void populateStageSparseOperationsPatterns(RewritePatternSet &patterns);
+
+std::unique_ptr<Pass> createStageSparseOperationsPass();
+
+//===----------------------------------------------------------------------===//
+// The PostSparsificationRewriting pass.
+//===----------------------------------------------------------------------===//
+
+void populatePostSparsificationRewriting(RewritePatternSet &patterns,
+                                         bool enableRT, bool enableForeach,
+                                         bool enableConvert);
+
+std::unique_ptr<Pass> createPostSparsificationRewritePass();
+std::unique_ptr<Pass>
+createPostSparsificationRewritePass(bool enableRT, bool enableForeach = true,
+                                    bool enableConvert = true);
+
+//===----------------------------------------------------------------------===//
+// The SparseTensorConversion pass.
+//===----------------------------------------------------------------------===//
+
+/// Sparse tensor type converter into an opaque pointer.
+class SparseTensorTypeToPtrConverter : public TypeConverter {
+public:
+  SparseTensorTypeToPtrConverter();
+};
+
+/// Defines a strategy for implementing sparse-to-sparse conversion.
+/// `kAuto` leaves it up to the compiler to automatically determine
+/// the method used.  `kViaCOO` converts the source tensor to COO and
+/// then converts the COO to the target format.  `kDirect` converts
+/// directly via the algorithm in <https://arxiv.org/abs/2001.02609>;
+/// however, beware that there are many formats not supported by this
+/// conversion method.
+enum class SparseToSparseConversionStrategy { kAuto, kViaCOO, kDirect };
+
+/// Converts command-line sparse2sparse flag to the strategy enum.
+SparseToSparseConversionStrategy sparseToSparseConversionStrategy(int32_t flag);
+
+/// SparseTensorConversion options.
+struct SparseTensorConversionOptions {
+  SparseTensorConversionOptions(SparseToSparseConversionStrategy s2s)
+      : sparseToSparseStrategy(s2s) {}
+  SparseTensorConversionOptions()
+      : SparseTensorConversionOptions(SparseToSparseConversionStrategy::kAuto) {
+  }
+  SparseToSparseConversionStrategy sparseToSparseStrategy;
+};
+
+/// Sets up sparse tensor conversion rules.
+void populateSparseTensorConversionPatterns(
+    TypeConverter &typeConverter, RewritePatternSet &patterns,
+    const SparseTensorConversionOptions &options =
+        SparseTensorConversionOptions());
+
+std::unique_ptr<Pass> createSparseTensorConversionPass();
+std::unique_ptr<Pass>
+createSparseTensorConversionPass(const SparseTensorConversionOptions &options);
+
+//===----------------------------------------------------------------------===//
+// The SparseTensorCodegen pass.
+//===----------------------------------------------------------------------===//
+
+/// Sparse tensor type converter into an actual buffer.
+class SparseTensorTypeToBufferConverter : public TypeConverter {
+public:
+  SparseTensorTypeToBufferConverter();
+};
+
+/// Sets up sparse tensor codegen rules.
+void populateSparseTensorCodegenPatterns(TypeConverter &typeConverter,
+                                         RewritePatternSet &patterns,
+                                         bool createSparseDeallocs,
+                                         bool enableBufferInitialization);
+
+std::unique_ptr<Pass> createSparseTensorCodegenPass();
+std::unique_ptr<Pass>
+createSparseTensorCodegenPass(bool createSparseDeallocs,
+                              bool enableBufferInitialization);
+
+//===----------------------------------------------------------------------===//
+// The SparseBufferRewrite pass.
+//===----------------------------------------------------------------------===//
+
+void populateSparseBufferRewriting(RewritePatternSet &patterns,
+                                   bool enableBufferInitialization);
+
+std::unique_ptr<Pass> createSparseBufferRewritePass();
+std::unique_ptr<Pass>
+createSparseBufferRewritePass(bool enableBufferInitialization);
+
+//===----------------------------------------------------------------------===//
+// The SparseVectorization pass.
+//===----------------------------------------------------------------------===//
+
+void populateSparseVectorizationPatterns(RewritePatternSet &patterns,
+                                         unsigned vectorLength,
+                                         bool enableVLAVectorization,
+                                         bool enableSIMDIndex32);
+
+std::unique_ptr<Pass> createSparseVectorizationPass();
+std::unique_ptr<Pass> createSparseVectorizationPass(unsigned vectorLength,
+                                                    bool enableVLAVectorization,
+                                                    bool enableSIMDIndex32);
+
+//===----------------------------------------------------------------------===//
+// The SparseGPU pass.
+//===----------------------------------------------------------------------===//
+
+void populateSparseGPUCodegenPatterns(RewritePatternSet &patterns,
+                                      unsigned numThreads);
+
+void populateSparseGPULibgenPatterns(RewritePatternSet &patterns, bool enableRT,
+                                     GPUDataTransferStrategy gpuDataTransfer);
+
+std::unique_ptr<Pass> createSparseGPUCodegenPass();
+std::unique_ptr<Pass> createSparseGPUCodegenPass(unsigned numThreads);
+
+//===----------------------------------------------------------------------===//
+// The SparseStorageSpecifierToLLVM pass.
+//===----------------------------------------------------------------------===//
+
+class StorageSpecifierToLLVMTypeConverter : public TypeConverter {
+public:
+  StorageSpecifierToLLVMTypeConverter();
+};
+
+void populateStorageSpecifierToLLVMPatterns(TypeConverter &converter,
+                                            RewritePatternSet &patterns);
+std::unique_ptr<Pass> createStorageSpecifierToLLVMPass();
+
+//===----------------------------------------------------------------------===//
+// The mini-pipeline for sparsification and bufferization.
+//===----------------------------------------------------------------------===//
+
+bufferization::OneShotBufferizationOptions
+getBufferizationOptionsForSparsification(bool analysisOnly);
+
+std::unique_ptr<Pass> createSparsificationAndBufferizationPass();
+
+std::unique_ptr<Pass> createSparsificationAndBufferizationPass(
+    const bufferization::OneShotBufferizationOptions &bufferizationOptions,
+    const SparsificationOptions &sparsificationOptions,
+    const SparseTensorConversionOptions &sparseTensorConversionOptions,
+    bool createSparseDeallocs, bool enableRuntimeLibrary,
+    bool enableBufferInitialization, unsigned vectorLength,
+    bool enableVLAVectorization, bool enableSIMDIndex32);
+
+//===----------------------------------------------------------------------===//
+// Registration.
+//===----------------------------------------------------------------------===//
+
+/// Generate the code for registering passes.
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
+
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.h.inc

@@ -0,0 +1,1758 @@
+/* Autogenerated by mlir-tblgen; don't manually edit */
+
+#ifdef GEN_PASS_DECL
+// Generate declarations for all passes.
+#define GEN_PASS_DECL_POSTSPARSIFICATIONREWRITE
+#define GEN_PASS_DECL_PRESPARSIFICATIONREWRITE
+#define GEN_PASS_DECL_SPARSEBUFFERREWRITE
+#define GEN_PASS_DECL_SPARSEGPUCODEGEN
+#define GEN_PASS_DECL_SPARSETENSORCODEGEN
+#define GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
+#define GEN_PASS_DECL_SPARSEVECTORIZATION
+#define GEN_PASS_DECL_SPARSIFICATIONANDBUFFERIZATION
+#define GEN_PASS_DECL_SPARSIFICATIONPASS
+#define GEN_PASS_DECL_STAGESPARSEOPERATIONS
+#define GEN_PASS_DECL_STORAGESPECIFIERTOLLVM
+#undef GEN_PASS_DECL
+#endif // GEN_PASS_DECL
+
+//===----------------------------------------------------------------------===//
+// PostSparsificationRewrite
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_POSTSPARSIFICATIONREWRITE
+struct PostSparsificationRewriteOptions {
+  bool enableRuntimeLibrary = true;
+  bool enableForeach = true;
+  bool enableConvert = true;
+};
+#undef GEN_PASS_DECL_POSTSPARSIFICATIONREWRITE
+#endif // GEN_PASS_DECL_POSTSPARSIFICATIONREWRITE
+#ifdef GEN_PASS_DEF_POSTSPARSIFICATIONREWRITE
+namespace impl {
+
+template <typename DerivedT>
+class PostSparsificationRewriteBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = PostSparsificationRewriteBase;
+
+  PostSparsificationRewriteBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  PostSparsificationRewriteBase(const PostSparsificationRewriteBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("post-sparsification-rewrite");
+  }
+  ::llvm::StringRef getArgument() const override { return "post-sparsification-rewrite"; }
+
+  ::llvm::StringRef getDescription() const override { return "Applies sparse tensor rewriting rules after sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("PostSparsificationRewrite");
+  }
+  ::llvm::StringRef getName() const override { return "PostSparsificationRewrite"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PostSparsificationRewriteBase<DerivedT>)
+
+  PostSparsificationRewriteBase(const PostSparsificationRewriteOptions &options) : PostSparsificationRewriteBase() {
+    enableRuntimeLibrary = options.enableRuntimeLibrary;
+    enableForeach = options.enableForeach;
+    enableConvert = options.enableConvert;
+  }
+protected:
+  ::mlir::Pass::Option<bool> enableRuntimeLibrary{*this, "enable-runtime-library", ::llvm::cl::desc("Enable runtime library for manipulating sparse tensors"), ::llvm::cl::init(true)};
+  ::mlir::Pass::Option<bool> enableForeach{*this, "enable-foreach", ::llvm::cl::desc("Enable rewriting rules for the foreach operator"), ::llvm::cl::init(true)};
+  ::mlir::Pass::Option<bool> enableConvert{*this, "enable-convert", ::llvm::cl::desc("Enable rewriting rules for the convert operator"), ::llvm::cl::init(true)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_POSTSPARSIFICATIONREWRITE
+#endif // GEN_PASS_DEF_POSTSPARSIFICATIONREWRITE
+
+//===----------------------------------------------------------------------===//
+// PreSparsificationRewrite
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_PRESPARSIFICATIONREWRITE
+#undef GEN_PASS_DECL_PRESPARSIFICATIONREWRITE
+#endif // GEN_PASS_DECL_PRESPARSIFICATIONREWRITE
+#ifdef GEN_PASS_DEF_PRESPARSIFICATIONREWRITE
+namespace impl {
+
+template <typename DerivedT>
+class PreSparsificationRewriteBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = PreSparsificationRewriteBase;
+
+  PreSparsificationRewriteBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  PreSparsificationRewriteBase(const PreSparsificationRewriteBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("pre-sparsification-rewrite");
+  }
+  ::llvm::StringRef getArgument() const override { return "pre-sparsification-rewrite"; }
+
+  ::llvm::StringRef getDescription() const override { return "Applies sparse tensor rewriting rules prior to sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("PreSparsificationRewrite");
+  }
+  ::llvm::StringRef getName() const override { return "PreSparsificationRewrite"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PreSparsificationRewriteBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_PRESPARSIFICATIONREWRITE
+#endif // GEN_PASS_DEF_PRESPARSIFICATIONREWRITE
+
+//===----------------------------------------------------------------------===//
+// SparseBufferRewrite
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSEBUFFERREWRITE
+struct SparseBufferRewriteOptions {
+  bool enableBufferInitialization = false;
+};
+#undef GEN_PASS_DECL_SPARSEBUFFERREWRITE
+#endif // GEN_PASS_DECL_SPARSEBUFFERREWRITE
+#ifdef GEN_PASS_DEF_SPARSEBUFFERREWRITE
+namespace impl {
+
+template <typename DerivedT>
+class SparseBufferRewriteBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseBufferRewriteBase;
+
+  SparseBufferRewriteBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseBufferRewriteBase(const SparseBufferRewriteBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-buffer-rewrite");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-buffer-rewrite"; }
+
+  ::llvm::StringRef getDescription() const override { return "Rewrite sparse primitives on buffers to actual code"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseBufferRewrite");
+  }
+  ::llvm::StringRef getName() const override { return "SparseBufferRewrite"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseBufferRewriteBase<DerivedT>)
+
+  SparseBufferRewriteBase(const SparseBufferRewriteOptions &options) : SparseBufferRewriteBase() {
+    enableBufferInitialization = options.enableBufferInitialization;
+  }
+protected:
+  ::mlir::Pass::Option<bool> enableBufferInitialization{*this, "enable-buffer-initialization", ::llvm::cl::desc("Enable zero-initialization of the memory buffers"), ::llvm::cl::init(false)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSEBUFFERREWRITE
+#endif // GEN_PASS_DEF_SPARSEBUFFERREWRITE
+
+//===----------------------------------------------------------------------===//
+// SparseGPUCodegen
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSEGPUCODEGEN
+struct SparseGPUCodegenOptions {
+  int32_t numThreads = 1024;
+};
+#undef GEN_PASS_DECL_SPARSEGPUCODEGEN
+#endif // GEN_PASS_DECL_SPARSEGPUCODEGEN
+#ifdef GEN_PASS_DEF_SPARSEGPUCODEGEN
+namespace impl {
+
+template <typename DerivedT>
+class SparseGPUCodegenBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseGPUCodegenBase;
+
+  SparseGPUCodegenBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseGPUCodegenBase(const SparseGPUCodegenBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-gpu-codegen");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-gpu-codegen"; }
+
+  ::llvm::StringRef getDescription() const override { return "Generates GPU code during sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseGPUCodegen");
+  }
+  ::llvm::StringRef getName() const override { return "SparseGPUCodegen"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<gpu::GPUDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseGPUCodegenBase<DerivedT>)
+
+  SparseGPUCodegenBase(const SparseGPUCodegenOptions &options) : SparseGPUCodegenBase() {
+    numThreads = options.numThreads;
+  }
+protected:
+  ::mlir::Pass::Option<int32_t> numThreads{*this, "num_threads", ::llvm::cl::desc("Sets the number of GPU threads"), ::llvm::cl::init(1024)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSEGPUCODEGEN
+#endif // GEN_PASS_DEF_SPARSEGPUCODEGEN
+
+//===----------------------------------------------------------------------===//
+// SparseTensorCodegen
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSETENSORCODEGEN
+struct SparseTensorCodegenOptions {
+  bool enableBufferInitialization = false;
+  bool createSparseDeallocs = true;
+};
+#undef GEN_PASS_DECL_SPARSETENSORCODEGEN
+#endif // GEN_PASS_DECL_SPARSETENSORCODEGEN
+#ifdef GEN_PASS_DEF_SPARSETENSORCODEGEN
+namespace impl {
+
+template <typename DerivedT>
+class SparseTensorCodegenBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseTensorCodegenBase;
+
+  SparseTensorCodegenBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseTensorCodegenBase(const SparseTensorCodegenBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-tensor-codegen");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-tensor-codegen"; }
+
+  ::llvm::StringRef getDescription() const override { return "Convert sparse tensors and primitives to actual code"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseTensorCodegen");
+  }
+  ::llvm::StringRef getName() const override { return "SparseTensorCodegen"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseTensorCodegenBase<DerivedT>)
+
+  SparseTensorCodegenBase(const SparseTensorCodegenOptions &options) : SparseTensorCodegenBase() {
+    enableBufferInitialization = options.enableBufferInitialization;
+    createSparseDeallocs = options.createSparseDeallocs;
+  }
+protected:
+  ::mlir::Pass::Option<bool> enableBufferInitialization{*this, "enable-buffer-initialization", ::llvm::cl::desc("Enable zero-initialization of the memory buffers"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<bool> createSparseDeallocs{*this, "create-sparse-deallocs", ::llvm::cl::desc("Specify if the temporary buffers created by the sparse compiler should be deallocated. For compatibility with core bufferization passes. This option is only used when enable-runtime-library=false. See also create-deallocs for BufferizationOption."), ::llvm::cl::init(true)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSETENSORCODEGEN
+#endif // GEN_PASS_DEF_SPARSETENSORCODEGEN
+
+//===----------------------------------------------------------------------===//
+// SparseTensorConversionPass
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
+struct SparseTensorConversionPassOptions {
+  int32_t sparseToSparse = 0;
+};
+#undef GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
+#endif // GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
+#ifdef GEN_PASS_DEF_SPARSETENSORCONVERSIONPASS
+namespace impl {
+
+template <typename DerivedT>
+class SparseTensorConversionPassBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseTensorConversionPassBase;
+
+  SparseTensorConversionPassBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseTensorConversionPassBase(const SparseTensorConversionPassBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-tensor-conversion");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-tensor-conversion"; }
+
+  ::llvm::StringRef getDescription() const override { return "Convert sparse tensors and primitives to library calls"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseTensorConversionPass");
+  }
+  ::llvm::StringRef getName() const override { return "SparseTensorConversionPass"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseTensorConversionPassBase<DerivedT>)
+
+  SparseTensorConversionPassBase(const SparseTensorConversionPassOptions &options) : SparseTensorConversionPassBase() {
+    sparseToSparse = options.sparseToSparse;
+  }
+protected:
+  ::mlir::Pass::Option<int32_t> sparseToSparse{*this, "s2s-strategy", ::llvm::cl::desc("Set the strategy for sparse-to-sparse conversion"), ::llvm::cl::init(0)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSETENSORCONVERSIONPASS
+#endif // GEN_PASS_DEF_SPARSETENSORCONVERSIONPASS
+
+//===----------------------------------------------------------------------===//
+// SparseVectorization
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSEVECTORIZATION
+struct SparseVectorizationOptions {
+  int32_t vectorLength = 0;
+  bool enableVLAVectorization = false;
+  bool enableSIMDIndex32 = false;
+};
+#undef GEN_PASS_DECL_SPARSEVECTORIZATION
+#endif // GEN_PASS_DECL_SPARSEVECTORIZATION
+#ifdef GEN_PASS_DEF_SPARSEVECTORIZATION
+namespace impl {
+
+template <typename DerivedT>
+class SparseVectorizationBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseVectorizationBase;
+
+  SparseVectorizationBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseVectorizationBase(const SparseVectorizationBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-vectorization");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-vectorization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Vectorizes loops after sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseVectorization");
+  }
+  ::llvm::StringRef getName() const override { return "SparseVectorization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  registry.insert<vector::VectorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseVectorizationBase<DerivedT>)
+
+  SparseVectorizationBase(const SparseVectorizationOptions &options) : SparseVectorizationBase() {
+    vectorLength = options.vectorLength;
+    enableVLAVectorization = options.enableVLAVectorization;
+    enableSIMDIndex32 = options.enableSIMDIndex32;
+  }
+protected:
+  ::mlir::Pass::Option<int32_t> vectorLength{*this, "vl", ::llvm::cl::desc("Set the vector length (use 0 to disable vectorization)"), ::llvm::cl::init(0)};
+  ::mlir::Pass::Option<bool> enableVLAVectorization{*this, "enable-vla-vectorization", ::llvm::cl::desc("Enable vector length agnostic vectorization"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<bool> enableSIMDIndex32{*this, "enable-simd-index32", ::llvm::cl::desc("Enable i32 indexing into vectors (for efficient gather/scatter)"), ::llvm::cl::init(false)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSEVECTORIZATION
+#endif // GEN_PASS_DEF_SPARSEVECTORIZATION
+
+//===----------------------------------------------------------------------===//
+// SparsificationAndBufferization
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSIFICATIONANDBUFFERIZATION
+#undef GEN_PASS_DECL_SPARSIFICATIONANDBUFFERIZATION
+#endif // GEN_PASS_DECL_SPARSIFICATIONANDBUFFERIZATION
+#ifdef GEN_PASS_DEF_SPARSIFICATIONANDBUFFERIZATION
+namespace impl {
+
+template <typename DerivedT>
+class SparsificationAndBufferizationBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparsificationAndBufferizationBase;
+
+  SparsificationAndBufferizationBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparsificationAndBufferizationBase(const SparsificationAndBufferizationBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparsification-and-bufferization");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparsification-and-bufferization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Mini-pipeline that combines bufferization and sparsifiation"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparsificationAndBufferization");
+  }
+  ::llvm::StringRef getName() const override { return "SparsificationAndBufferization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<gpu::GPUDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparsificationAndBufferizationBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSIFICATIONANDBUFFERIZATION
+#endif // GEN_PASS_DEF_SPARSIFICATIONANDBUFFERIZATION
+
+//===----------------------------------------------------------------------===//
+// SparsificationPass
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_SPARSIFICATIONPASS
+struct SparsificationPassOptions {
+  bool enableIndexReduction = false;
+  mlir::SparseParallelizationStrategy parallelization = mlir::SparseParallelizationStrategy::kNone;
+  mlir::GPUDataTransferStrategy gpuDataTransfer = mlir::GPUDataTransferStrategy::kRegularDMA;
+  bool enableGPULibgen = false;
+  bool enableRuntimeLibrary = true;
+};
+#undef GEN_PASS_DECL_SPARSIFICATIONPASS
+#endif // GEN_PASS_DECL_SPARSIFICATIONPASS
+#ifdef GEN_PASS_DEF_SPARSIFICATIONPASS
+namespace impl {
+
+template <typename DerivedT>
+class SparsificationPassBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparsificationPassBase;
+
+  SparsificationPassBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparsificationPassBase(const SparsificationPassBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparsification");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparsification"; }
+
+  ::llvm::StringRef getDescription() const override { return "Automatically generate sparse tensor code from sparse tensor types"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparsificationPass");
+  }
+  ::llvm::StringRef getName() const override { return "SparsificationPass"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<gpu::GPUDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparsificationPassBase<DerivedT>)
+
+  SparsificationPassBase(const SparsificationPassOptions &options) : SparsificationPassBase() {
+    enableIndexReduction = options.enableIndexReduction;
+    parallelization = options.parallelization;
+    gpuDataTransfer = options.gpuDataTransfer;
+    enableGPULibgen = options.enableGPULibgen;
+    enableRuntimeLibrary = options.enableRuntimeLibrary;
+  }
+protected:
+  ::mlir::Pass::Option<bool> enableIndexReduction{*this, "enable-index-reduction", ::llvm::cl::desc("Enable dependent index reduction based algorithm to handle non-trivial index expressions on sparse inputs (experimental features)"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<mlir::SparseParallelizationStrategy> parallelization{*this, "parallelization-strategy", ::llvm::cl::desc("Set the parallelization strategy"), ::llvm::cl::init(mlir::SparseParallelizationStrategy::kNone), llvm::cl::values(
+             clEnumValN(mlir::SparseParallelizationStrategy::kNone, "none",
+                        "Turn off sparse parallelization."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kDenseOuterLoop,
+                        "dense-outer-loop",
+                        "Enable dense outer loop sparse parallelization."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kAnyStorageOuterLoop,
+                        "any-storage-outer-loop",
+                        "Enable sparse parallelization regardless of storage for the outer loop."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kDenseAnyLoop,
+                        "dense-any-loop",
+                        "Enable dense parallelization for any loop."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kAnyStorageAnyLoop,
+                        "any-storage-any-loop",
+                        "Enable sparse parallelization for any storage and loop."))};
+  ::mlir::Pass::Option<mlir::GPUDataTransferStrategy> gpuDataTransfer{*this, "gpu-data-transfer-strategy", ::llvm::cl::desc("Set the data transfer strategy"), ::llvm::cl::init(mlir::GPUDataTransferStrategy::kRegularDMA), llvm::cl::values(
+               clEnumValN(mlir::GPUDataTransferStrategy::kRegularDMA,
+                     "regular-dma",
+                     "Default option: malloc on host without additional "
+                     "options or care and then use DMA to copy the data"),
+          clEnumValN(mlir::GPUDataTransferStrategy::kPinnedDMA, "pinned-dma",
+                     "Based on the default option, pin the host memory to "
+                     "accelerate the data transfer"),
+          clEnumValN(mlir::GPUDataTransferStrategy::kZeroCopy, "zero-copy",
+                     "Use zero-copy to perform the data transfer from the host "
+                     "to the GPU"))};
+  ::mlir::Pass::Option<bool> enableGPULibgen{*this, "enable-gpu-libgen", ::llvm::cl::desc("Enable GPU acceleration by means of direct library calls (like cuSPARSE)"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<bool> enableRuntimeLibrary{*this, "enable-runtime-library", ::llvm::cl::desc("Enable runtime library for manipulating sparse tensors"), ::llvm::cl::init(true)};
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_SPARSIFICATIONPASS
+#endif // GEN_PASS_DEF_SPARSIFICATIONPASS
+
+//===----------------------------------------------------------------------===//
+// StageSparseOperations
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_STAGESPARSEOPERATIONS
+#undef GEN_PASS_DECL_STAGESPARSEOPERATIONS
+#endif // GEN_PASS_DECL_STAGESPARSEOPERATIONS
+#ifdef GEN_PASS_DEF_STAGESPARSEOPERATIONS
+namespace impl {
+
+template <typename DerivedT>
+class StageSparseOperationsBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = StageSparseOperationsBase;
+
+  StageSparseOperationsBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  StageSparseOperationsBase(const StageSparseOperationsBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("stage-sparse-ops");
+  }
+  ::llvm::StringRef getArgument() const override { return "stage-sparse-ops"; }
+
+  ::llvm::StringRef getDescription() const override { return "Decompose a complex sparse operation into multiple stages"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("StageSparseOperations");
+  }
+  ::llvm::StringRef getName() const override { return "StageSparseOperations"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(StageSparseOperationsBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_STAGESPARSEOPERATIONS
+#endif // GEN_PASS_DEF_STAGESPARSEOPERATIONS
+
+//===----------------------------------------------------------------------===//
+// StorageSpecifierToLLVM
+//===----------------------------------------------------------------------===//
+#ifdef GEN_PASS_DECL_STORAGESPECIFIERTOLLVM
+#undef GEN_PASS_DECL_STORAGESPECIFIERTOLLVM
+#endif // GEN_PASS_DECL_STORAGESPECIFIERTOLLVM
+#ifdef GEN_PASS_DEF_STORAGESPECIFIERTOLLVM
+namespace impl {
+
+template <typename DerivedT>
+class StorageSpecifierToLLVMBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = StorageSpecifierToLLVMBase;
+
+  StorageSpecifierToLLVMBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  StorageSpecifierToLLVMBase(const StorageSpecifierToLLVMBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-storage-specifier-to-llvm");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-storage-specifier-to-llvm"; }
+
+  ::llvm::StringRef getDescription() const override { return "Lower sparse storage specifer to llvm structure"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("StorageSpecifierToLLVM");
+  }
+  ::llvm::StringRef getName() const override { return "StorageSpecifierToLLVM"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(StorageSpecifierToLLVMBase<DerivedT>)
+
+protected:
+private:
+};
+} // namespace impl
+#undef GEN_PASS_DEF_STORAGESPECIFIERTOLLVM
+#endif // GEN_PASS_DEF_STORAGESPECIFIERTOLLVM
+#ifdef GEN_PASS_REGISTRATION
+
+//===----------------------------------------------------------------------===//
+// PostSparsificationRewrite Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerPostSparsificationRewrite() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createPostSparsificationRewritePass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerPostSparsificationRewritePass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createPostSparsificationRewritePass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// PreSparsificationRewrite Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerPreSparsificationRewrite() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createPreSparsificationRewritePass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerPreSparsificationRewritePass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createPreSparsificationRewritePass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparseBufferRewrite Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparseBufferRewrite() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseBufferRewritePass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparseBufferRewritePass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseBufferRewritePass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparseGPUCodegen Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparseGPUCodegen() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseGPUCodegenPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparseGPUCodegenPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseGPUCodegenPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparseTensorCodegen Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparseTensorCodegen() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseTensorCodegenPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparseTensorCodegenPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseTensorCodegenPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparseTensorConversionPass Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparseTensorConversionPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseTensorConversionPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparseTensorConversionPassPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseTensorConversionPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparseVectorization Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparseVectorization() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseVectorizationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparseVectorizationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparseVectorizationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparsificationAndBufferization Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparsificationAndBufferization() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparsificationAndBufferizationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparsificationAndBufferizationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparsificationAndBufferizationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparsificationPass Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparsificationPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparsificationPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerSparsificationPassPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createSparsificationPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// StageSparseOperations Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerStageSparseOperations() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createStageSparseOperationsPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerStageSparseOperationsPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createStageSparseOperationsPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// StorageSpecifierToLLVM Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerStorageSpecifierToLLVM() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createStorageSpecifierToLLVMPass();
+  });
+}
+
+// Old registration code, kept for temporary backwards compatibility.
+inline void registerStorageSpecifierToLLVMPass() {
+  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
+    return mlir::createStorageSpecifierToLLVMPass();
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// SparseTensor Registration
+//===----------------------------------------------------------------------===//
+
+inline void registerSparseTensorPasses() {
+  registerPostSparsificationRewrite();
+  registerPreSparsificationRewrite();
+  registerSparseBufferRewrite();
+  registerSparseGPUCodegen();
+  registerSparseTensorCodegen();
+  registerSparseTensorConversionPass();
+  registerSparseVectorization();
+  registerSparsificationAndBufferization();
+  registerSparsificationPass();
+  registerStageSparseOperations();
+  registerStorageSpecifierToLLVM();
+}
+#undef GEN_PASS_REGISTRATION
+#endif // GEN_PASS_REGISTRATION
+// Deprecated. Please use the new per-pass macros.
+#ifdef GEN_PASS_CLASSES
+
+template <typename DerivedT>
+class PostSparsificationRewriteBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = PostSparsificationRewriteBase;
+
+  PostSparsificationRewriteBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  PostSparsificationRewriteBase(const PostSparsificationRewriteBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("post-sparsification-rewrite");
+  }
+  ::llvm::StringRef getArgument() const override { return "post-sparsification-rewrite"; }
+
+  ::llvm::StringRef getDescription() const override { return "Applies sparse tensor rewriting rules after sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("PostSparsificationRewrite");
+  }
+  ::llvm::StringRef getName() const override { return "PostSparsificationRewrite"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PostSparsificationRewriteBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<bool> enableRuntimeLibrary{*this, "enable-runtime-library", ::llvm::cl::desc("Enable runtime library for manipulating sparse tensors"), ::llvm::cl::init(true)};
+  ::mlir::Pass::Option<bool> enableForeach{*this, "enable-foreach", ::llvm::cl::desc("Enable rewriting rules for the foreach operator"), ::llvm::cl::init(true)};
+  ::mlir::Pass::Option<bool> enableConvert{*this, "enable-convert", ::llvm::cl::desc("Enable rewriting rules for the convert operator"), ::llvm::cl::init(true)};
+};
+
+template <typename DerivedT>
+class PreSparsificationRewriteBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = PreSparsificationRewriteBase;
+
+  PreSparsificationRewriteBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  PreSparsificationRewriteBase(const PreSparsificationRewriteBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("pre-sparsification-rewrite");
+  }
+  ::llvm::StringRef getArgument() const override { return "pre-sparsification-rewrite"; }
+
+  ::llvm::StringRef getDescription() const override { return "Applies sparse tensor rewriting rules prior to sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("PreSparsificationRewrite");
+  }
+  ::llvm::StringRef getName() const override { return "PreSparsificationRewrite"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PreSparsificationRewriteBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SparseBufferRewriteBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseBufferRewriteBase;
+
+  SparseBufferRewriteBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseBufferRewriteBase(const SparseBufferRewriteBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-buffer-rewrite");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-buffer-rewrite"; }
+
+  ::llvm::StringRef getDescription() const override { return "Rewrite sparse primitives on buffers to actual code"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseBufferRewrite");
+  }
+  ::llvm::StringRef getName() const override { return "SparseBufferRewrite"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseBufferRewriteBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<bool> enableBufferInitialization{*this, "enable-buffer-initialization", ::llvm::cl::desc("Enable zero-initialization of the memory buffers"), ::llvm::cl::init(false)};
+};
+
+template <typename DerivedT>
+class SparseGPUCodegenBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseGPUCodegenBase;
+
+  SparseGPUCodegenBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseGPUCodegenBase(const SparseGPUCodegenBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-gpu-codegen");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-gpu-codegen"; }
+
+  ::llvm::StringRef getDescription() const override { return "Generates GPU code during sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseGPUCodegen");
+  }
+  ::llvm::StringRef getName() const override { return "SparseGPUCodegen"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<gpu::GPUDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseGPUCodegenBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<int32_t> numThreads{*this, "num_threads", ::llvm::cl::desc("Sets the number of GPU threads"), ::llvm::cl::init(1024)};
+};
+
+template <typename DerivedT>
+class SparseTensorCodegenBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseTensorCodegenBase;
+
+  SparseTensorCodegenBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseTensorCodegenBase(const SparseTensorCodegenBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-tensor-codegen");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-tensor-codegen"; }
+
+  ::llvm::StringRef getDescription() const override { return "Convert sparse tensors and primitives to actual code"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseTensorCodegen");
+  }
+  ::llvm::StringRef getName() const override { return "SparseTensorCodegen"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseTensorCodegenBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<bool> enableBufferInitialization{*this, "enable-buffer-initialization", ::llvm::cl::desc("Enable zero-initialization of the memory buffers"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<bool> createSparseDeallocs{*this, "create-sparse-deallocs", ::llvm::cl::desc("Specify if the temporary buffers created by the sparse compiler should be deallocated. For compatibility with core bufferization passes. This option is only used when enable-runtime-library=false. See also create-deallocs for BufferizationOption."), ::llvm::cl::init(true)};
+};
+
+template <typename DerivedT>
+class SparseTensorConversionPassBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseTensorConversionPassBase;
+
+  SparseTensorConversionPassBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseTensorConversionPassBase(const SparseTensorConversionPassBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-tensor-conversion");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-tensor-conversion"; }
+
+  ::llvm::StringRef getDescription() const override { return "Convert sparse tensors and primitives to library calls"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseTensorConversionPass");
+  }
+  ::llvm::StringRef getName() const override { return "SparseTensorConversionPass"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseTensorConversionPassBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<int32_t> sparseToSparse{*this, "s2s-strategy", ::llvm::cl::desc("Set the strategy for sparse-to-sparse conversion"), ::llvm::cl::init(0)};
+};
+
+template <typename DerivedT>
+class SparseVectorizationBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparseVectorizationBase;
+
+  SparseVectorizationBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparseVectorizationBase(const SparseVectorizationBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-vectorization");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-vectorization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Vectorizes loops after sparsification"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparseVectorization");
+  }
+  ::llvm::StringRef getName() const override { return "SparseVectorization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  registry.insert<vector::VectorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparseVectorizationBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<int32_t> vectorLength{*this, "vl", ::llvm::cl::desc("Set the vector length (use 0 to disable vectorization)"), ::llvm::cl::init(0)};
+  ::mlir::Pass::Option<bool> enableVLAVectorization{*this, "enable-vla-vectorization", ::llvm::cl::desc("Enable vector length agnostic vectorization"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<bool> enableSIMDIndex32{*this, "enable-simd-index32", ::llvm::cl::desc("Enable i32 indexing into vectors (for efficient gather/scatter)"), ::llvm::cl::init(false)};
+};
+
+template <typename DerivedT>
+class SparsificationAndBufferizationBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparsificationAndBufferizationBase;
+
+  SparsificationAndBufferizationBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparsificationAndBufferizationBase(const SparsificationAndBufferizationBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparsification-and-bufferization");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparsification-and-bufferization"; }
+
+  ::llvm::StringRef getDescription() const override { return "Mini-pipeline that combines bufferization and sparsifiation"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparsificationAndBufferization");
+  }
+  ::llvm::StringRef getName() const override { return "SparsificationAndBufferization"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<gpu::GPUDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparsificationAndBufferizationBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class SparsificationPassBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = SparsificationPassBase;
+
+  SparsificationPassBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  SparsificationPassBase(const SparsificationPassBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparsification");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparsification"; }
+
+  ::llvm::StringRef getDescription() const override { return "Automatically generate sparse tensor code from sparse tensor types"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("SparsificationPass");
+  }
+  ::llvm::StringRef getName() const override { return "SparsificationPass"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<affine::AffineDialect>();
+
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<bufferization::BufferizationDialect>();
+
+  registry.insert<gpu::GPUDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<linalg::LinalgDialect>();
+
+  registry.insert<memref::MemRefDialect>();
+
+  registry.insert<scf::SCFDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SparsificationPassBase<DerivedT>)
+
+protected:
+  ::mlir::Pass::Option<bool> enableIndexReduction{*this, "enable-index-reduction", ::llvm::cl::desc("Enable dependent index reduction based algorithm to handle non-trivial index expressions on sparse inputs (experimental features)"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<mlir::SparseParallelizationStrategy> parallelization{*this, "parallelization-strategy", ::llvm::cl::desc("Set the parallelization strategy"), ::llvm::cl::init(mlir::SparseParallelizationStrategy::kNone), llvm::cl::values(
+             clEnumValN(mlir::SparseParallelizationStrategy::kNone, "none",
+                        "Turn off sparse parallelization."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kDenseOuterLoop,
+                        "dense-outer-loop",
+                        "Enable dense outer loop sparse parallelization."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kAnyStorageOuterLoop,
+                        "any-storage-outer-loop",
+                        "Enable sparse parallelization regardless of storage for the outer loop."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kDenseAnyLoop,
+                        "dense-any-loop",
+                        "Enable dense parallelization for any loop."),
+             clEnumValN(mlir::SparseParallelizationStrategy::kAnyStorageAnyLoop,
+                        "any-storage-any-loop",
+                        "Enable sparse parallelization for any storage and loop."))};
+  ::mlir::Pass::Option<mlir::GPUDataTransferStrategy> gpuDataTransfer{*this, "gpu-data-transfer-strategy", ::llvm::cl::desc("Set the data transfer strategy"), ::llvm::cl::init(mlir::GPUDataTransferStrategy::kRegularDMA), llvm::cl::values(
+               clEnumValN(mlir::GPUDataTransferStrategy::kRegularDMA,
+                     "regular-dma",
+                     "Default option: malloc on host without additional "
+                     "options or care and then use DMA to copy the data"),
+          clEnumValN(mlir::GPUDataTransferStrategy::kPinnedDMA, "pinned-dma",
+                     "Based on the default option, pin the host memory to "
+                     "accelerate the data transfer"),
+          clEnumValN(mlir::GPUDataTransferStrategy::kZeroCopy, "zero-copy",
+                     "Use zero-copy to perform the data transfer from the host "
+                     "to the GPU"))};
+  ::mlir::Pass::Option<bool> enableGPULibgen{*this, "enable-gpu-libgen", ::llvm::cl::desc("Enable GPU acceleration by means of direct library calls (like cuSPARSE)"), ::llvm::cl::init(false)};
+  ::mlir::Pass::Option<bool> enableRuntimeLibrary{*this, "enable-runtime-library", ::llvm::cl::desc("Enable runtime library for manipulating sparse tensors"), ::llvm::cl::init(true)};
+};
+
+template <typename DerivedT>
+class StageSparseOperationsBase : public ::mlir::OperationPass<func::FuncOp> {
+public:
+  using Base = StageSparseOperationsBase;
+
+  StageSparseOperationsBase() : ::mlir::OperationPass<func::FuncOp>(::mlir::TypeID::get<DerivedT>()) {}
+  StageSparseOperationsBase(const StageSparseOperationsBase &other) : ::mlir::OperationPass<func::FuncOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("stage-sparse-ops");
+  }
+  ::llvm::StringRef getArgument() const override { return "stage-sparse-ops"; }
+
+  ::llvm::StringRef getDescription() const override { return "Decompose a complex sparse operation into multiple stages"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("StageSparseOperations");
+  }
+  ::llvm::StringRef getName() const override { return "StageSparseOperations"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(StageSparseOperationsBase<DerivedT>)
+
+protected:
+};
+
+template <typename DerivedT>
+class StorageSpecifierToLLVMBase : public ::mlir::OperationPass<ModuleOp> {
+public:
+  using Base = StorageSpecifierToLLVMBase;
+
+  StorageSpecifierToLLVMBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
+  StorageSpecifierToLLVMBase(const StorageSpecifierToLLVMBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}
+
+  /// Returns the command-line argument attached to this pass.
+  static constexpr ::llvm::StringLiteral getArgumentName() {
+    return ::llvm::StringLiteral("sparse-storage-specifier-to-llvm");
+  }
+  ::llvm::StringRef getArgument() const override { return "sparse-storage-specifier-to-llvm"; }
+
+  ::llvm::StringRef getDescription() const override { return "Lower sparse storage specifer to llvm structure"; }
+
+  /// Returns the derived pass name.
+  static constexpr ::llvm::StringLiteral getPassName() {
+    return ::llvm::StringLiteral("StorageSpecifierToLLVM");
+  }
+  ::llvm::StringRef getName() const override { return "StorageSpecifierToLLVM"; }
+
+  /// Support isa/dyn_cast functionality for the derived pass class.
+  static bool classof(const ::mlir::Pass *pass) {
+    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
+  }
+
+  /// A clone method to create a copy of this pass.
+  std::unique_ptr<::mlir::Pass> clonePass() const override {
+    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
+  }
+
+  /// Return the dialect that must be loaded in the context before this pass.
+  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
+    
+  registry.insert<arith::ArithDialect>();
+
+  registry.insert<LLVM::LLVMDialect>();
+
+  registry.insert<sparse_tensor::SparseTensorDialect>();
+
+  }
+
+  /// Explicitly declare the TypeID for this class. We declare an explicit private
+  /// instantiation because Pass classes should only be visible by the current
+  /// library.
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(StorageSpecifierToLLVMBase<DerivedT>)
+
+protected:
+};
+#undef GEN_PASS_CLASSES
+#endif // GEN_PASS_CLASSES

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/external/llvm-project/mlir/include/mlir/Dialect/SparseTensor/Utils/Merger.h

@@ -0,0 +1,744 @@
+//===- Merger.h - Utilities for defining lattices ---------------*- 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 header file defines utilities for dealing with iteration lattices.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_SPARSETENSOR_UTILS_MERGER_H_
+#define MLIR_DIALECT_SPARSETENSOR_UTILS_MERGER_H_
+
+#include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/SparseTensor/IR/Enums.h"
+#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
+#include "mlir/IR/Value.h"
+#include "llvm/ADT/BitVector.h"
+
+#include <optional>
+
+namespace mlir {
+namespace sparse_tensor {
+
+namespace detail {
+/// A constant serving as the canonically invalid identifier,
+/// regardless of the identifier type.
+static constexpr unsigned kInvalidId = -1u;
+} // namespace detail
+
+/// Tensor identifiers, chosen to be the `BlockArgument::getArgNumber`
+/// of the value passed to `Merger::buildTensorExp`.
+using TensorId = unsigned;
+
+/// Loop identifiers.
+using LoopId = unsigned;
+
+/// A compressed representation of `std::pair<TensorId, LoopId>`.
+/// The compression scheme is such that this also serves as an index
+/// into the bitvector stored in `LatPoint` (since that bitvector is
+/// just the implementation for a set of `TensorLoopId` values).
+using TensorLoopId = unsigned;
+
+/// `TensorExp` identifiers. These are allocated by `Merger::addExp`,
+/// and serve as unique identifiers for the corresponding `TensorExp` object.
+using ExprId = unsigned;
+
+/// `LatPoint` identifiers. These are allocated by `Merger::addLat`,
+/// and serve as unique identifiers for the corresponding `LatPoint` object.
+using LatPointId = unsigned;
+
+/// `LatSet` identifiers.  These are allocated by `Merger::addSet` (and
+/// by other methods calling that one), and serve as unique identifiers
+/// for the corresponding `SmallVector<LatPointId>` object.
+using LatSetId = unsigned;
+
+/// A pair of level and its corresponding DimLevelType of a tensor.
+using LvlDLTPair = std::pair<Level, DimLevelType>;
+
+/// A pair of loop id and its coefficients. E.g., for affine expression in the
+/// affine map `2 * d0`, loop id = 0, coefficient = 2.
+using LoopCoeffPair = std::pair<LoopId, unsigned>;
+
+/// Tensor expression. Represents an MLIR expression in tensor index notation.
+struct TensorExp final {
+  enum class Kind;
+
+  /// Child subexpressions for non-leaf expressions.
+  struct Children final {
+    ExprId e0;
+    ExprId e1;
+  };
+
+  /// The `x` parameter has different types depending on the value of the
+  /// `k` parameter.  The correspondences are:
+  /// * `kTensor`    -> `TensorId`
+  /// * `kInvariant` -> `kInvalidId`
+  /// * `kLoopVar`   -> `LoopId`
+  /// * else         -> `ExprId`
+  ///
+  /// The `y`, `v`, and `op` parameters either must or must not be
+  /// `kInvalidId`/`nullptr`, depending on the value of the `k` parameter;
+  /// however, they have uniform C++ types regardless of the value of `k`.
+  TensorExp(Kind k, unsigned x, ExprId y, Value v, Operation *op, Attribute a);
+
+  /// Tensor expression kind.
+  Kind kind;
+
+  union {
+    /// `kTensor` expressions simply have a tensor identifier.
+    TensorId tensor;
+
+    /// `kLoopVar` expressions simply have a loop identifier.
+    LoopId loop;
+
+    /// All other expressions hold the `ExprId`s of their children.
+    Children children;
+  };
+
+  /// Direct link to IR for an invariant or the destination value (to
+  /// infer destination type) of a cast operation During code generation,
+  /// this field may be used to cache "hoisted" loop invariant tensor loads.
+  Value val;
+
+  /// Code blocks used by semirings. For the case of kUnary, kBinary, kReduce,
+  /// and kSelect, this holds the original operation with all regions. For
+  /// kBinaryBranch, this holds the YieldOp for the left or right half
+  /// to be merged into a nested scf loop.
+  ///
+  /// Or the actual operation that we can not sparsify but having all dense
+  /// operands for kDenseOp.
+  Operation *op;
+
+  /// An optional attribute that is required to determine the semantics of the
+  /// operations. E.g., CmpPredicateAttr for CmpI/CmpF operations.
+  Attribute attr;
+};
+
+/// Tensor expression kind.
+///
+/// The `kLoopVar` leaf kind is for representing `linalg::IndexOp`.
+/// That is, its argument is a `LoopId` identifying the loop-variable
+/// in question, and its value will be the current iteration's value
+/// of that loop-variable.  See the `LoopId` documentation for more details.
+///
+/// The `kSynZero` leaf kind is for representing a synthetic zero value, which
+/// can be introduced when sparsifying operations like `arith::cmp` to generate
+/// `arith::cmp %lhs, %syn_zero` when the rhs operand is absent.
+//
+// TODO: Modify this definition so that the numeric values already encode
+// the `ExpArity` (while extending the notion of "arity" to include not
+// just the number of `ExprId` children the node has, but also whether the
+// node has a `Value` and/or `Operation*`).  Doing this will avoid needing
+// to enumerate all the kinds in `getExpArity` and in the `TensorExp` ctor,
+// and should help clean up a few other places as well.
+enum class TensorExp::Kind {
+  // Leaf.
+  kTensor = 0,
+  kSynZero,
+  kInvariant,
+  kLoopVar,
+  // Unary operations.
+  kAbsF,
+  kAbsC,
+  kAbsI,
+  kCeilF,
+  kFloorF,
+  kSqrtF,
+  kSqrtC,
+  kExpm1F,
+  kExpm1C,
+  kLog1pF,
+  kLog1pC,
+  kSinF,
+  kSinC,
+  kTanhF,
+  kTanhC,
+  kNegF,
+  kNegC,
+  kNegI,
+  kTruncF,
+  kExtF,
+  kCastFS, // signed
+  kCastFU, // unsigned
+  kCastSF, // signed
+  kCastUF, // unsigned
+  kCastS,  // signed
+  kCastU,  // unsigned
+  kCastIdx,
+  kTruncI,
+  kCIm, // complex.im
+  kCRe, // complex.re
+  kBitCast,
+  kBinaryBranch, // semiring unary branch created from a binary op
+  kUnary,        // semiring unary op
+  kSelect,       // custom selection criteria
+  // Binary operations.
+  kMulF,
+  kMulC,
+  kMulI,
+  kDivF,
+  kDivC, // complex
+  kDivS, // signed
+  kDivU, // unsigned
+  kAddF,
+  kAddC,
+  kAddI,
+  kSubF,
+  kSubC,
+  kSubI,
+  kAndI,
+  kOrI,
+  kXorI,
+  kCmpI,
+  kCmpF,
+  kShrS, // signed
+  kShrU, // unsigned
+  kShlI,
+  kBinary,  // semiring binary op
+  kReduce,  // semiring reduction op
+  kDenseOp, // special category of operations requiring all dense operands
+};
+
+/// Lattice point.  Each lattice point consists of a formal conjunction
+/// of `TensorLoopId`s, together with the identifier of the corresponding
+/// tensor expression.  The formal conjunction is represented as a set of
+/// `TensorLoopId`, where that set is implemented as a `BitVector`.
+struct LatPoint final {
+  /// Construct a lattice point with the empty set of `TensorLoopId`s.
+  LatPoint(unsigned size, ExprId e) : bits(size, false), exp(e) {}
+
+  /// Construct a lattice point from the given set of `TensorLoopId`s.
+  LatPoint(const BitVector &bits, ExprId e) : bits(bits), exp(e) {}
+
+  /// Conjunction of all `TensorLoopId`s involved in the tensor expression.
+  BitVector bits;
+
+  /// Simplified conjunction of `TensorLoopId` as bitvector.  This
+  /// represents a simplified condition under which this tensor expression
+  /// must execute. Pre-computed during codegen to avoid repeated eval.
+  BitVector simple;
+
+  /// Identifier of the tensor expression.
+  ExprId exp;
+};
+
+/// A class to handle all iteration lattice operations. This class abstracts
+/// away from some implementation details of storing iteration lattices and
+/// tensor expressions. This allows for fine-tuning performance characteristics
+/// independently from the basic algorithm if bottlenecks are identified.
+class Merger {
+public:
+  /// Constructs a merger for the given number of tensors, native loops, and
+  /// filter loops. The user supplies the number of tensors involved in the
+  /// kernel, with the last tensor in this set denoting the output tensor.
+  /// The merger adds an additional synthetic tensor at the end of this set
+  /// to represent all invariant expressions in the kernel.
+  ///
+  /// In addition to natives loops (which are specified by the GenericOp),
+  /// extra filter loops are needed in order to handle affine expressions on
+  /// sparse levels.  E.g., (d0, d1, d2) => (d0 + d1, d2), a naive
+  /// implementation of the filter loop could be generated as
+  ///
+  /// for (const auto c0 : coordinates[0]) {
+  ///   if (c0 == d0 + d1) {
+  ///      generated_code;
+  ///   }
+  /// }
+  ///
+  /// to filter out coordinates that are not equal to the affine expression.
+  ///
+  /// The maxLvlRank specifies the max level rank of all inputs/output tensors.
+  /// It is used to pre-allocate sufficient memory for internal storage.
+  //
+  // TODO: we want to make the filter loop more efficient in the future,
+  // e.g., by avoiding scanning the full list of stored coordinates (keeping
+  // the last position in ordered list) or even apply binary search to find
+  // the coordinate.
+  //
+  // TODO: would be cleaner to understand/document if the first argument
+  // gave the number of input tensors, instead of the current number of
+  // input+output tensors.
+  Merger(unsigned numInputOutputTensors, unsigned numNativeLoops,
+         unsigned numFilterLoops, unsigned maxLvlRank);
+
+  //
+  // Constructing valid tensor and loop identifiers.
+  //
+
+  /// Safely converts the argument to a tensor identifier.
+  constexpr TensorId makeTensorId(unsigned t) const {
+    assert(isValidTensorId(t));
+    return t;
+  }
+
+  /// Safely converts the argument to a loop identifier.
+  constexpr LoopId makeLoopId(unsigned i) const {
+    assert(isValidLoopId(i));
+    return i;
+  }
+
+  /// Safely converts the arguments to a pair of (tensor,loop) identifiers.
+  constexpr TensorLoopId makeTensorLoopId(unsigned t, unsigned i) const {
+    assert(isValidTensorId(t) && isValidLoopId(i));
+    return numTensors * i + t;
+  }
+
+  //
+  // Allocating new expressions, points, and sets.
+  //
+
+  /// Constructs a new tensor expression, and returns its identifier.
+  ExprId addTensorExp(TensorId t);
+  /// Constructs a new loop-variable expression, and returns its identifier.
+  ExprId addLoopVarExp(LoopId i);
+  /// Constructs a new invariant expression, and returns its identifier.
+  ExprId addInvariantExp(Value v);
+  /// Constructs a new synthetic zero expression.
+  ExprId addSynZeroExp();
+  /// Constructs a new unary or binary expression, and returns its identifier.
+  ExprId addExp(TensorExp::Kind k, ExprId e0, ExprId e1 = detail::kInvalidId,
+                Operation *op = nullptr, Attribute attr = nullptr);
+  /// Constructs a new sesquinary expression, and returns its identifier.
+  /// Currently no sesquinary `Kind` allows specifying the `op`, but we
+  /// allow it anyways because `mapSet` is designed to allow it.
+  ExprId addExp(TensorExp::Kind k, ExprId e, Value v, Operation *op = nullptr,
+                Attribute attr = nullptr);
+
+  /// Constructs a new iteration lattice point, and returns its identifier.
+  LatPointId addLat(TensorId t, LoopId i, ExprId e);
+  LatPointId addLat(const BitVector &bits, ExprId e);
+
+  /// Constructs a new (initially empty) set, and returns its identifier.
+  LatSetId addSet();
+
+  /// Computes a single conjunction of two lattice points by taking the "union"
+  /// of `LoopId` (effectively constructing a larger "intersection" of those
+  /// loops) with a newly constructed tensor (sub)expression of given kind.
+  /// Returns the identifier of the new lattice point.
+  LatPointId conjLat(ExprId e, LatPointId p0, LatPointId p1,
+                     Operation *op = nullptr);
+
+  /// Conjunctive merge of two lattice sets: `(s0 /\_op s1)`.
+  /// Returns the identifier of the new set.
+  LatSetId conjSet(ExprId e, LatSetId s0, LatSetId s1, Operation *op = nullptr);
+
+  /// Disjunctive merge of two lattice sets: `(s0 /\_op s1, s0, s1)`.
+  /// Returns the identifier of the new set.
+  LatSetId disjSet(ExprId e, LatSetId s0, LatSetId s1, Operation *op = nullptr);
+
+  /// Disjunctive merge of two lattice sets and also set one of the operand to
+  /// zero: `(s0 /\_op s1 (e0 op e1), s0 (0 op e0), s1 (e1 op 0))`.
+  /// Returns the identifier of the new set.
+  LatSetId disjSetWithZero(ExprId e, LatSetId s0, LatSetId s1);
+
+  /// Disjunctive merge of two lattice sets with custom handling of the
+  /// overlap, left, and right regions.  Any region may be left missing
+  /// in the output.  Returns the identifier of the new set.
+  LatSetId combiSet(ExprId e, LatSetId s0, LatSetId s1, Operation *orig,
+                    bool includeLeft, TensorExp::Kind ltrans, Operation *opleft,
+                    bool includeRight, TensorExp::Kind rtrans,
+                    Operation *opright);
+
+  /// Maps the unary operator over the lattice set of the operand, i.e. each
+  /// lattice point on an expression E is simply copied over, but with OP E
+  /// as new expression. Returns the identifier of the new set.
+  LatSetId mapSet(TensorExp::Kind kind, LatSetId s, Value v = Value(),
+                  Operation *op = nullptr);
+
+  /// Maps the binary operator to the same operation but with one of its operand
+  /// set to zero, i.e. each lattice point on an expression E is simply copied
+  /// over, but with `OP 0 E` (if lhsZero == true) or `OP E 0` (if lhsZero ==
+  /// false) as new expression. Returns the identifier of the new set.
+  LatSetId mapBinWithSynZeroSet(ExprId e, LatSetId s, bool lhsZero);
+
+  /// Optimizes the iteration lattice points in the given set. This
+  /// method should be called right before code generation to avoid
+  /// generating redundant loops and conditions.
+  LatSetId optimizeSet(LatSetId s);
+
+  /// Simplifies the conditions in a conjunction of a given lattice point
+  /// within the given set using just two basic rules:
+  /// (1) multiple dense conditions are reduced to single dense, and
+  /// (2) a *singleton* sparse/dense is reduced to sparse/random access.
+  BitVector simplifyCond(LatSetId s, LatPointId p);
+
+  /// Returns true if p0 > p1.
+  bool latGT(LatPointId p0, LatPointId p1) const;
+
+  /// Returns true if p0 and p1 only differ in dense.
+  bool onlyDenseDiff(LatPointId p0, LatPointId p1) const;
+
+  /// Gets the tensor-identifier of the `TensorLoopId`.
+  constexpr TensorId tensor(TensorLoopId b) const { return b % numTensors; }
+  /// Gets the loop-identifier of the `TensorLoopId`.
+  constexpr LoopId loop(TensorLoopId b) const { return b / numTensors; }
+
+  /// Gets the total number of tensors (including the output-tensor and
+  /// synthetic-tensor).
+  constexpr unsigned getNumTensors() const { return numTensors; }
+
+  /// Gets the total number of loops (native loops + filter loops).
+  constexpr unsigned getNumLoops() const { return numLoops; }
+  /// Gets the number of native loops.
+  constexpr unsigned getNumNativeLoops() const { return numNativeLoops; }
+  /// Gets the number of filter loops.
+  constexpr unsigned getNumFilterLoops() const {
+    return numLoops - numNativeLoops;
+  }
+  /// Gets the identifier of the first filter-loop.
+  constexpr LoopId getStartingFilterLoopId() const {
+    return getNumNativeLoops();
+  }
+
+  /// Returns true if `b` is the `i`th loop of the output tensor.
+  constexpr bool isOutTensor(TensorLoopId b, LoopId i) const {
+    return b == makeTensorLoopId(outTensor, i);
+  }
+
+  /// Gets the output tensor's identifier.
+  constexpr TensorId getOutTensorID() const { return outTensor; }
+
+  /// Gets the synthetic tensor's identifier (used for all invariant
+  /// tensor expressions).
+  constexpr TensorId getSynTensorID() const { return syntheticTensor; }
+
+  constexpr bool isFilterLoop(LoopId i) const {
+    assert(isValidLoopId(i));
+    return i >= numNativeLoops;
+  }
+
+  /// Returns true if the expression is `(kTensor t)`.
+  bool expIsTensor(ExprId e, TensorId t) const {
+    const auto &expr = exp(e);
+    return expr.kind == TensorExp::Kind::kTensor && expr.tensor == t;
+  }
+
+  /// Returns true if the expression contains the tensor as an operand.
+  bool expContainsTensor(ExprId e, TensorId t) const;
+
+  /// Returns true if the expression contains a negation on output tensor.
+  /// I.e., `- outTensor` or `exp - outputTensor`
+  /// NOTE: this is an trivial tests in that it does not handle recursive
+  /// negation, i.e., it returns true when the expression is `-(-tensor)`.
+  bool hasNegateOnOut(ExprId e) const;
+
+  /// Returns true if given tensor iterates *only* in the given tensor
+  /// expression. For the output tensor, this defines a "simply dynamic"
+  /// operation [Bik96]. For instance: a(i) *= 2.0 or a(i) += a(i) for
+  /// sparse vector a.
+  bool isSingleCondition(TensorId t, ExprId e) const;
+
+  /// Returns true if any `TensorLoopId` in the bitvector corresponds
+  /// to sparse level-type.
+  bool hasAnySparse(const BitVector &bits) const;
+
+  /// Returns true if bits contains a dependent index reduction condition on
+  /// sparse levels.
+  bool hasSparseIdxReduction(const BitVector &bits) const;
+
+  /// Gets the level-type of the `t`th tensor on `i`th loop.
+  DimLevelType getLvlType(TensorId t, LoopId i) const {
+    assert(isValidTensorId(t) && isValidLoopId(i));
+    return lvlTypes[t][i];
+  }
+
+  /// Gets the level-type of the TensorLoopId.
+  DimLevelType getLvlType(TensorLoopId b) const {
+    return getLvlType(tensor(b), loop(b));
+  }
+
+  /// Gets the loop identifier for the `lvl`th level of the `t`th tensor.
+  std::optional<LoopId> getLoopId(TensorId t, Level lvl) const {
+    assert(isValidLevel(t, lvl));
+    return lvlToLoop[t][lvl];
+  }
+
+  /// Gets the level number of the the `t`th tensor on `i`th loop.
+  std::optional<Level> getLvl(TensorId t, LoopId i) const {
+    assert(isValidTensorId(t) && isValidLoopId(i));
+    return loopToLvl[t][i];
+  }
+  std::optional<Level> getLvl(TensorLoopId b) const {
+    return getLvl(tensor(b), loop(b));
+  }
+
+  /// Sets the level number and level-type of the `t`th tensor on
+  /// `i`th loop.
+  void setLevelAndType(TensorId t, LoopId i, Level lvl, DimLevelType dlt) {
+    assert(isValidLevel(t, lvl) && isValidLoopId(i) && isValidDLT(dlt));
+    lvlTypes[t][i] = dlt;
+    loopToLvl[t][i] = lvl;
+    lvlToLoop[t][lvl] = i;
+    // TODO: Maybe we should favor a constant loop bound when there are multiple
+    // choices.
+    loopBounds[i] = std::make_pair(t, lvl);
+  }
+
+  using ForeachTensorLoopIdCallback = function_ref<void(
+      TensorLoopId, TensorId, std::optional<Level>, DimLevelType, bool)>;
+
+  /// Iterates over a set of `TensorLoopId`s, invoking the callback
+  /// for each `TensorLoopId` and passing it the corresponding tensor
+  /// identifier, level, and level-type, following with a boolean value
+  /// indicating whether it is a dependent index reduction loop condition.
+  void foreachTensorLoopId(LatPointId p,
+                           ForeachTensorLoopIdCallback callback) const {
+    // TODO: the default ought to be simple=true; but we'll need to make
+    // sure to update all the tests to make sure they do the right thing.
+    foreachTensorLoopId(p, /*simple=*/false, callback);
+  }
+  void foreachTensorLoopId(LatPointId p, bool simple,
+                           ForeachTensorLoopIdCallback callback) const {
+    const auto &point = lat(p);
+    const auto &bits = simple ? point.simple : point.bits;
+    for (const TensorLoopId b : bits.set_bits()) {
+      const TensorId t = tensor(b);
+      const auto optLvl = getLvl(b);
+      const auto lvlTp = getLvlType(b);
+      if (isLvlWithNonTrivialIdxExp(b)) {
+        // This must be an undefined level.
+        assert(!optLvl.has_value());
+        // Slice the tid along the dependent level to iterate current loop.
+        callback(b, t, getLoopDependentLevel(b), lvlTp,
+                 /*isIdxReduc=*/true);
+      } else {
+        callback(b, t, optLvl, lvlTp, /*isIdxReduc=*/false);
+      }
+    }
+  }
+
+  /// Sets whether the output tensor is sparse or not.
+  void setHasSparseOut(bool s) { hasSparseOut = s; }
+
+  /// Establishes the two-way map that i <-> <t, lvl, dlt>.
+  void setLoopDependentTensorLevel(LoopId i, TensorId t, Level lvl,
+                                   DimLevelType dlt, unsigned coefficient) {
+    assert(isValidLoopId(i) && isValidLevel(t, lvl));
+    assert(!loopToUnresolvedLvls[i][t].has_value()); // must be the first def
+    loopToUnresolvedLvls[i][t] = std::make_pair(lvl, dlt);
+    levelToDependentLoop[t][lvl].emplace_back(i, coefficient);
+  }
+
+  /// Whether the loop has dependent slice.
+  bool hasDependentLvl(LoopId i, TensorId t) {
+    assert(isValidTensorId(t) && isValidLoopId(i));
+    return loopToUnresolvedLvls[i][t].has_value();
+  }
+
+  /// Returns the list of loop indices which appear in the non-trivial index
+  /// expression on t_l, e.g., A[i+j] => {i, j}
+  std::vector<LoopCoeffPair> &getDependentLoops(TensorId t, Level lvl) {
+    assert(isValidLevel(t, lvl));
+    return levelToDependentLoop[t][lvl];
+  }
+
+  /// Returns the defining [tid, lvl] for the loop.
+  std::pair<TensorId, Level> getLoopDefiningLvl(LoopId i) const {
+    assert(isValidLoopId(i));
+    return loopBounds[i];
+  }
+
+  /// Checks whether the TensorLoopId represents a tensor level contains
+  /// non-trivial index expression.
+  bool isLvlWithNonTrivialIdxExp(TensorLoopId b) const {
+    const TensorId t = tensor(b);
+    const LoopId i = loop(b);
+    assert(isValidTensorId(t) && isValidLoopId(i));
+    return loopToUnresolvedLvls[i][t].has_value();
+  }
+
+  /// Checks whether the TensorLoopId represents a sparse tensor level contains
+  /// non-trivial index expression.
+  bool isSparseLvlWithNonTrivialIdxExp(TensorLoopId b) const {
+    if (isLvlWithNonTrivialIdxExp(b)) {
+      auto dlt = getLoopDependentLevelType(b);
+      return isCompressedDLT(dlt) || isSingletonDLT(dlt);
+    }
+    return false;
+  }
+
+  Level getLoopDependentLevel(TensorLoopId b) const {
+    assert(isLvlWithNonTrivialIdxExp(b));
+    return loopToUnresolvedLvls[loop(b)][tensor(b)]->first;
+  }
+
+  DimLevelType getLoopDependentLevelType(TensorLoopId b) const {
+    assert(isLvlWithNonTrivialIdxExp(b));
+    return loopToUnresolvedLvls[loop(b)][tensor(b)]->second;
+  }
+
+  /// Convenience getters to immediately access the stored nodes.
+  /// These methods return `const&` because the underlying objects must
+  /// not be mutated by client code.  The only exception is for mutating
+  /// the value associated with an expression, for which there are
+  /// dedicated methods below.
+  ///
+  /// NOTE: It is inadvisable to keep the reference alive for a long
+  /// time (e.g., as in `TensorExpr &te = merger.exp(e)`), since insertions
+  /// into the merger can cause data movement which will invalidate the
+  /// underlying memory address.  This isn't just a problem with the `&`
+  /// references, but also applies to the `ArrayRef`.  In particular,
+  /// using `for (LatPointId p : merger.set(s))` will run into the same
+  /// dangling-reference problems if the loop body inserts new sets.
+  const TensorExp &exp(ExprId e) const {
+    assert(isValidExprId(e));
+    return tensorExps[e];
+  }
+  const LatPoint &lat(LatPointId p) const {
+    assert(isValidLatPointId(p));
+    return latPoints[p];
+  }
+  ArrayRef<LatPointId> set(LatSetId s) const {
+    assert(isValidLatSetId(s));
+    return latSets[s];
+  }
+
+  /// Checks whether the given expression has an associated value.
+  bool hasExprValue(ExprId e) const { return static_cast<bool>(exp(e).val); }
+
+  /// Sets the expression to have the associated value.  Asserts that
+  /// the new value is defined, and that the expression does not already
+  /// have a value.  If you want to overwrite a previous associated value,
+  /// use `updateExprValue` instead.
+  void setExprValue(ExprId e, Value v) {
+    assert(isValidExprId(e));
+    assert(v && "Got an undefined value");
+    auto &val = tensorExps[e].val;
+    assert(!val && "Expression already has an associated value");
+    val = v;
+  }
+
+  /// Clears the value associated with the expression.  Asserts that the
+  /// expression does indeed have an associated value before clearing it.
+  /// If you don't want to check for a previous associated value first,
+  /// then use `updateExprValue` instead.
+  void clearExprValue(ExprId e) {
+    assert(isValidExprId(e));
+    auto &val = tensorExps[e].val;
+    assert(val && "Expression does not have an associated value to clear");
+    val = Value();
+  }
+
+  /// Unilaterally updates the expression to have the associated value.
+  /// That is, unlike `setExprValue` and `clearExprValue`, this method
+  /// does not perform any checks on whether the expression had a
+  /// previously associated value nor whether the new value is defined.
+  //
+  // TODO: The unilateral update semantics are required by the
+  // current implementation of `CodegenEnv::genLoopBoundary`; however,
+  // that implementation seems a bit dubious.  We would much rather have
+  // the semantics `{ clearExprValue(e); setExprValue(e, v); }` or
+  // `{ clearExprValue(e); if (v) setExprValue(e, v); }` since those
+  // provide better invariants.
+  void updateExprValue(ExprId e, Value v) {
+    assert(isValidExprId(e));
+    tensorExps[e].val = v;
+  }
+
+#ifndef NDEBUG
+  /// Print methods (for debugging).
+  void dumpExp(ExprId e) const;
+  void dumpLat(LatPointId p) const;
+  void dumpSet(LatSetId s) const;
+  void dumpBits(const BitVector &bits) const;
+#endif
+
+  /// Builds the iteration lattices in a bottom-up traversal given the
+  /// remaining tensor (sub)expression and the next loop in the iteration
+  /// graph.  Returns the identifier of the root set.
+  LatSetId buildLattices(ExprId e, LoopId i);
+
+  /// Builds a tensor expression from the given Linalg operation.
+  /// On success, returns the identifier of the root expression.
+  std::optional<ExprId> buildTensorExpFromLinalg(linalg::GenericOp op);
+
+  /// Rebuilds SSA format from a tensor expression.
+  Value buildExp(RewriterBase &rewriter, Location loc, ExprId e, Value v0,
+                 Value v1) const;
+
+private:
+  /// Private helpers.
+  constexpr bool isValidTensorId(TensorId t) const { return t < numTensors; }
+  constexpr bool isValidLoopId(LoopId i) const {
+    return i != detail::kInvalidId && i < numLoops;
+  }
+  bool isValidLevel(TensorId t, Level lvl) const {
+    assert(levelToDependentLoop[t].size() == lvlToLoop[t].size());
+    return isValidTensorId(t) && lvl < lvlToLoop[t].size();
+  }
+  bool isValidExprId(ExprId e) const {
+    return e != detail::kInvalidId && e < tensorExps.size();
+  }
+  bool isValidLatPointId(LatPointId p) const {
+    return p != detail::kInvalidId && p < latPoints.size();
+  }
+  bool isValidLatSetId(LatSetId s) const {
+    return s != detail::kInvalidId && s < latSets.size();
+  }
+  bool maybeZero(ExprId e) const;
+  bool isInvariant(ExprId e) const {
+    return exp(e).kind == TensorExp::Kind::kInvariant;
+  }
+  Type inferType(ExprId e, Value src) const;
+
+  /// Traverses the SSA tree (possibly a DAG) to build a tensor expression.
+  /// The boolean value returned indicates whether the result of the current
+  /// operation being built depends on any value that is loaded from a sparse
+  /// tensor.
+  std::pair<std::optional<ExprId>, bool> buildTensorExp(linalg::GenericOp op,
+                                                        Value v);
+
+  /// Merger data structures.
+  const TensorId outTensor;
+  const TensorId syntheticTensor;
+  const unsigned numTensors;
+  const unsigned numNativeLoops;
+  const unsigned numLoops;
+  bool hasSparseOut;
+
+  // Below we use `std::vector` for things which have a priori fixed
+  // sizes, whereas we use `llvm::SmallVector` for things with variable
+  // size.  Do beware that these two classes differ in the semantics of
+  // `operator[]`: `SmallVector` performs OOB checks, whereas `std::vector`
+  // does not.
+
+  /// Map that converts pair<TensorId, LoopId> to the corresponding
+  /// level-type.
+  std::vector<std::vector<DimLevelType>> lvlTypes;
+
+  /// Map that converts pair<TensorId, LoopId> to the corresponding
+  /// level.
+  std::vector<std::vector<std::optional<Level>>> loopToLvl;
+
+  /// Map that converts pair<TensorId, Level> to the corresponding LoopId.
+  std::vector<std::vector<std::optional<LoopId>>> lvlToLoop;
+
+  /// Map from a loop to its dependencies if any.
+  /// The dependencies of a loop is a set of (tensor, level) pairs.
+  /// It is currently only set for non-trivial index expressions.
+  /// E.g., A[i+j] => i and j will have dependencies {A0, dlt(A0)} to indicate
+  /// that i and j are used in the non-trivial index expression on A0.
+  std::vector<std::vector<std::optional<LvlDLTPair>>> loopToUnresolvedLvls;
+
+  /// The inverse map of ldxToDependencies from tensor level -> dependent loop
+  /// E.g., A[2i+j], we have A0 => {(2, i), (1, j)}, to indicate that A0 uses
+  /// both {i, j} to compute its indices and the coefficients on the loop id are
+  /// 2 and 1 respectively.
+  std::vector<std::vector<std::vector<LoopCoeffPair>>> levelToDependentLoop;
+
+  /// Map from a loop to the [tid, lvl] pair that defines the loop boundary.
+  std::vector<std::pair<TensorId, Level>> loopBounds;
+
+  llvm::SmallVector<TensorExp> tensorExps;
+  llvm::SmallVector<LatPoint> latPoints;
+  llvm::SmallVector<SmallVector<LatPointId>> latSets;
+};
+
+} // namespace sparse_tensor
+} // namespace mlir
+
+#endif // MLIR_DIALECT_SPARSETENSOR_UTILS_MERGER_H_