[mlir] Remove getNumberOfExecutions from RegionBranchOpInterface

[ezhulenev]

Summary

getNumRegionInvocations was originally added for the async reference counting, but turned out to be not useful, and currently is not used anywhere (couldn't find any uses in public github repos). Removing dead code.

[mehdi_amini]

Thanks for the cleanup!

mlir/include/mlir/Analysis/NumberOfExecutions.h

-//===- NumberOfExecutions.h - Number of executions analysis -----*- 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 an analysis for computing how many times a block within a
-// region is executed *each time* that region is entered. The analysis
-// iterates over all associated regions that are attached to the given top-level
-// operation.
-//
-// It is possible to query number of executions information on block level.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_ANALYSIS_NUMBEROFEXECUTIONS_H
-#define MLIR_ANALYSIS_NUMBEROFEXECUTIONS_H
-
-#include "mlir/Support/LLVM.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
-
-namespace mlir {
-
-class Block;
-class BlockNumberOfExecutionsInfo;
-class Operation;
-class Region;
-
-/// Represents an analysis for computing how many times a block or an operation
-/// within a region is executed *each time* that region is entered. The analysis
-/// iterates over all associated regions that are attached to the given
-/// top-level operation.
-///
-/// This analysis assumes that all operations complete in a finite amount of
-/// time (do not abort and do not go into the infinite loop).
-class NumberOfExecutions {
-public:
-  /// Creates a new NumberOfExecutions analysis that computes how many times a
-  /// block within a region is executed for all associated regions.
-  explicit NumberOfExecutions(Operation *op);
-
-  /// Returns the number of times operations `op` is executed *each time* the
-  /// control flow enters the region `perEntryOfThisRegion`. Returns empty
-  /// optional if this is not known statically.
-  Optional<int64_t> getNumberOfExecutions(Operation *op,
-                                          Region *perEntryOfThisRegion) const;
-
-  /// Returns the number of times block `block` is executed *each time* the
-  /// control flow enters the region `perEntryOfThisRegion`. Returns empty
-  /// optional if this is not known statically.
-  Optional<int64_t> getNumberOfExecutions(Block *block,
-                                          Region *perEntryOfThisRegion) const;
-
-  /// Dumps the number of block executions *each time* the control flow enters
-  /// the region `perEntryOfThisRegion` to the given stream.
-  void printBlockExecutions(raw_ostream &os,
-                            Region *perEntryOfThisRegion) const;
-
-  /// Dumps the number of operation executions *each time* the control flow
-  /// enters the region `perEntryOfThisRegion` to the given stream.
-  void printOperationExecutions(raw_ostream &os,
-                                Region *perEntryOfThisRegion) const;
-
-private:
-  /// The operation this analysis was constructed from.
-  Operation *operation;
-
-  /// A mapping from blocks to number of executions information.
-  DenseMap<Block *, BlockNumberOfExecutionsInfo> blockNumbersOfExecution;
-};
-
-/// Represents number of block executions information.
-class BlockNumberOfExecutionsInfo {
-public:
-  BlockNumberOfExecutionsInfo(Block *block,
-                              Optional<int64_t> numberOfRegionInvocations,
-                              Optional<int64_t> numberOfBlockExecutions);
-
-  /// Returns the number of times this block will be executed *each time* the
-  /// parent operation is executed.
-  Optional<int64_t> getNumberOfExecutions() const;
-
-  /// Returns the number of times this block will be executed if the parent
-  /// region is invoked `numberOfRegionInvocations` times. This can be different
-  /// from the number of region invocations by the parent operation.
-  Optional<int64_t>
-  getNumberOfExecutions(int64_t numberOfRegionInvocations) const;
-
-  Block *getBlock() const { return block; }
-
-private:
-  Block *block;
-
-  /// Number of `block` parent region invocations *each time* parent operation
-  /// is executed.
-  Optional<int64_t> numberOfRegionInvocations;
-
-  /// Number of `block` executions *each time* parent region is invoked.
-  Optional<int64_t> numberOfBlockExecutions;
-};
-
-} // namespace mlir
-
-#endif // MLIR_ANALYSIS_NUMBEROFEXECUTIONS_H

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

 
 // Base class for the operation in this dialect
 class Async_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<AsyncDialect, mnemonic, traits>;
 
 def Async_ExecuteOp :
   Async_Op<"execute", [SingleBlockImplicitTerminator<"YieldOp">,
                        DeclareOpInterfaceMethods<RegionBranchOpInterface,
-                                                 ["getSuccessorEntryOperands",
-                                                  "getNumRegionInvocations"]>,
+                                                 ["getSuccessorEntryOperands"]>,
                        AttrSizedOperandSegments]> {
   let summary = "Asynchronous execute operation";
   let description = [{
     The `body` region attached to the `async.execute` operation semantically
     can be executed concurrently with the successor operation. In the followup
     example "compute0" can be executed concurrently with "compute1".
 
     The actual concurrency semantics depends on the dialect lowering to the

mlir/include/mlir/Dialect/SCF/SCFOps.td

OpOperand &getOpOperandForResult(OpResult opResult) {
         getNumControlOperands() + opResult.getResultNumber());
     }
 
     /// Return operands used when entering the region at 'index'. These operands
     /// correspond to the loop iterator operands, i.e., those exclusing the
     /// induction variable. LoopOp only has one region, so 0 is the only valid
     /// value for `index`.
     OperandRange getSuccessorEntryOperands(unsigned index);
-
-    /// Returns the number of invocations of the body block if the loop bounds
-    /// are constants. Returns `kUnknownNumRegionInvocations` otherwise.
-    void getNumRegionInvocations(ArrayRef<Attribute> operands,
-                                 SmallVectorImpl<int64_t> &countPerRegion);
   }];
 
   let hasCanonicalizer = 1;
 }
 
 def IfOp : SCF_Op<"if",
       [DeclareOpInterfaceMethods<RegionBranchOpInterface>,
        SingleBlockImplicitTerminator<"scf::YieldOp">, RecursiveSideEffects,
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();
-
-    /// If the condition is a constant, returns 1 for the executed block and 0
-    /// for the other. Otherwise, returns `kUnknownNumRegionInvocations` for
-    /// both successors.
-    void getNumRegionInvocations(ArrayRef<Attribute> operands,
-                                 SmallVectorImpl<int64_t> &countPerRegion);
   }];
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 def ParallelOp : SCF_Op<"parallel",
     [AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<LoopLikeOpInterface>,

mlir/include/mlir/Interfaces/ControlFlowInterfaces.h

 LogicalResult verifyBranchSuccessorOperands(Operation *op, unsigned succNo,
                                             Optional<OperandRange> operands);
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // RegionBranchOpInterface
 //===----------------------------------------------------------------------===//
 
-// A constant value to represent unknown number of region invocations.
-extern const int64_t kUnknownNumRegionInvocations;
-
 namespace detail {
 /// Verify that types match along control flow edges described the given op.
 LogicalResult verifyTypesAlongControlFlowEdges(Operation *op);
 } //  namespace detail
 
 /// This class represents a successor of a region. A region successor can either
 /// be another region, or the parent operation. If the successor is a region,
 /// this class represents the destination region, as well as a set of arguments

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

InterfaceMethod<[{
         operation as a successor. This method allows for describing which
         regions may be executed when entering an operation, and which regions
         are executed after having executed another region of the parent op. The
         successor region must be non-empty.
       }],
       "void", "getSuccessorRegions",
       (ins "::mlir::Optional<unsigned>":$index, "::mlir::ArrayRef<::mlir::Attribute>":$operands,
            "::mlir::SmallVectorImpl<::mlir::RegionSuccessor> &":$regions)
-    >,
-    InterfaceMethod<[{
-        Populates countPerRegion with the number of times this operation will
-        invoke the attached regions (assuming the regions yield normally, i.e.
-        do not abort or invoke an infinite loop). If the number of region
-        invocations is not known statically it will set the number of
-        invocations to `kUnknownNumRegionInvocations`.
-
-        `operands` is a set of optional attributes that either correspond to a
-        constant values for each operand of this operation, or null if that
-        operand is not a constant.
-      }],
-      "void", "getNumRegionInvocations",
-      (ins "::mlir::ArrayRef<::mlir::Attribute>":$operands,
-           "::mlir::SmallVectorImpl<int64_t> &":$countPerRegion), [{}],
-      /*defaultImplementation=*/[{
-        unsigned numRegions = this->getOperation()->getNumRegions();
-        assert(countPerRegion.empty());
-        countPerRegion.resize(numRegions, kUnknownNumRegionInvocations);
-      }]
     >
   ];
 
   let verify = [{
     static_assert(!ConcreteOp::template hasTrait<OpTrait::ZeroRegion>(),
                   "expected operation to have non-zero regions");
     return success();
   }];

mlir/lib/Analysis/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   AliasAnalysis.cpp
   AffineAnalysis.cpp
   AffineStructures.cpp
   BufferViewFlowAnalysis.cpp
   CallGraph.cpp
   DataFlowAnalysis.cpp
   DataLayoutAnalysis.cpp
   Liveness.cpp
   LoopAnalysis.cpp
   NestedMatcher.cpp
-  NumberOfExecutions.cpp
   SliceAnalysis.cpp
   Utils.cpp
 
   AliasAnalysis/LocalAliasAnalysis.cpp
   )
 
 add_mlir_library(MLIRAnalysis
   AliasAnalysis.cpp
   BufferViewFlowAnalysis.cpp
   CallGraph.cpp
   DataFlowAnalysis.cpp
   DataLayoutAnalysis.cpp
   Liveness.cpp
-  NumberOfExecutions.cpp
   SliceAnalysis.cpp
 
   AliasAnalysis/LocalAliasAnalysis.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Analysis
 
   DEPENDS

mlir/lib/Analysis/NumberOfExecutions.cpp

-//===- NumberOfExecutions.cpp - Number of executions analysis -------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// Implementation of the number of executions analysis.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/NumberOfExecutions.h"
-#include "mlir/IR/Matchers.h"
-#include "mlir/IR/RegionKindInterface.h"
-#include "mlir/Interfaces/ControlFlowInterfaces.h"
-
-#include "llvm/ADT/FunctionExtras.h"
-#include "llvm/ADT/SmallSet.h"
-#include "llvm/Support/raw_ostream.h"
-
-#define DEBUG_TYPE "number-of-executions-analysis"
-
-using namespace mlir;
-
-//===----------------------------------------------------------------------===//
-// NumberOfExecutions
-//===----------------------------------------------------------------------===//
-
-/// Computes blocks number of executions information for the given region.
-static void computeRegionBlockNumberOfExecutions(
-    Region &region, DenseMap<Block *, BlockNumberOfExecutionsInfo> &blockInfo) {
-  Operation *parentOp = region.getParentOp();
-  int regionId = region.getRegionNumber();
-
-  auto regionKindInterface = dyn_cast<RegionKindInterface>(parentOp);
-  bool isGraphRegion =
-      regionKindInterface &&
-      regionKindInterface.getRegionKind(regionId) == RegionKind::Graph;
-
-  // CFG analysis does not make sense for Graph regions, set the number of
-  // executions for all blocks as unknown.
-  if (isGraphRegion) {
-    for (Block &block : region)
-      blockInfo.insert({&block, {&block, None, None}});
-    return;
-  }
-
-  // Number of region invocations for all attached regions.
-  SmallVector<int64_t, 4> numRegionsInvocations;
-
-  // Query RegionBranchOpInterface interface if it is available.
-  if (auto regionInterface = dyn_cast<RegionBranchOpInterface>(parentOp)) {
-    SmallVector<Attribute, 4> operands(parentOp->getNumOperands());
-    for (const auto &operandIt : llvm::enumerate(parentOp->getOperands()))
-      matchPattern(operandIt.value(), m_Constant(&operands[operandIt.index()]));
-
-    regionInterface.getNumRegionInvocations(operands, numRegionsInvocations);
-  }
-
-  // Number of region invocations *each time* parent operation is invoked.
-  Optional<int64_t> numRegionInvocations;
-
-  if (!numRegionsInvocations.empty() &&
-      numRegionsInvocations[regionId] != kUnknownNumRegionInvocations) {
-    numRegionInvocations = numRegionsInvocations[regionId];
-  }
-
-  // DFS traversal looking for loops in the CFG.
-  llvm::SmallSet<Block *, 4> loopStart;
-
-  llvm::unique_function<void(Block *, llvm::SmallSet<Block *, 4> &)> dfs =
-      [&](Block *block, llvm::SmallSet<Block *, 4> &visited) {
-        // Found a loop in the CFG that starts at the `block`.
-        if (visited.contains(block)) {
-          loopStart.insert(block);
-          return;
-        }
-
-        // Continue DFS traversal.
-        visited.insert(block);
-        for (Block *successor : block->getSuccessors())
-          dfs(successor, visited);
-        visited.erase(block);
-      };
-
-  llvm::SmallSet<Block *, 4> visited;
-  dfs(&region.front(), visited);
-
-  // Start from the entry block and follow only blocks with single succesor.
-  Block *block = &region.front();
-  while (block && !loopStart.contains(block)) {
-    // Block will be executed exactly once.
-    blockInfo.insert(
-        {block, BlockNumberOfExecutionsInfo(block, numRegionInvocations,
-                                            /*numberOfBlockExecutions=*/1)});
-
-    // We reached the exit block or block with multiple successors.
-    if (block->getNumSuccessors() != 1)
-      break;
-
-    // Continue traversal.
-    block = block->getSuccessor(0);
-  }
-
-  // For all blocks that we did not visit set the executions number to unknown.
-  for (Block &block : region)
-    if (blockInfo.count(&block) == 0)
-      blockInfo.insert({&block, BlockNumberOfExecutionsInfo(
-                                    &block, numRegionInvocations,
-                                    /*numberOfBlockExecutions=*/None)});
-}
-
-/// Creates a new NumberOfExecutions analysis that computes how many times a
-/// block within a region is executed for all associated regions.
-NumberOfExecutions::NumberOfExecutions(Operation *op) : operation(op) {
-  operation->walk<WalkOrder::PreOrder>([&](Region *region) {
-    computeRegionBlockNumberOfExecutions(*region, blockNumbersOfExecution);
-  });
-}
-
-Optional<int64_t>
-NumberOfExecutions::getNumberOfExecutions(Operation *op,
-                                          Region *perEntryOfThisRegion) const {
-  // Assuming that all operations complete in a finite amount of time (do not
-  // abort and do not go into the infinite loop), the number of operation
-  // executions is equal to the number of block executions that contains the
-  // operation.
-  return getNumberOfExecutions(op->getBlock(), perEntryOfThisRegion);
-}
-
-Optional<int64_t>
-NumberOfExecutions::getNumberOfExecutions(Block *block,
-                                          Region *perEntryOfThisRegion) const {
-  // Return None if the given `block` does not lie inside the
-  // `perEntryOfThisRegion` region.
-  if (!perEntryOfThisRegion->findAncestorBlockInRegion(*block))
-    return None;
-
-  // Find the block information for the given `block.
-  auto blockIt = blockNumbersOfExecution.find(block);
-  if (blockIt == blockNumbersOfExecution.end())
-    return None;
-  const auto &blockInfo = blockIt->getSecond();
-
-  // Override the number of region invocations with `1` if the
-  // `perEntryOfThisRegion` region owns the block.
-  auto getNumberOfExecutions = [&](const BlockNumberOfExecutionsInfo &info) {
-    if (info.getBlock()->getParent() == perEntryOfThisRegion)
-      return info.getNumberOfExecutions(/*numberOfRegionInvocations=*/1);
-    return info.getNumberOfExecutions();
-  };
-
-  // Immediately return None if we do not know the block number of executions.
-  auto blockExecutions = getNumberOfExecutions(blockInfo);
-  if (!blockExecutions.hasValue())
-    return None;
-
-  // Follow parent operations until we reach the operations that owns the
-  // `perEntryOfThisRegion`.
-  int64_t numberOfExecutions = *blockExecutions;
-  Operation *parentOp = block->getParentOp();
-
-  while (parentOp != perEntryOfThisRegion->getParentOp()) {
-    // Find how many times will be executed the block that owns the parent
-    // operation.
-    Block *parentBlock = parentOp->getBlock();
-
-    auto parentBlockIt = blockNumbersOfExecution.find(parentBlock);
-    if (parentBlockIt == blockNumbersOfExecution.end())
-      return None;
-    const auto &parentBlockInfo = parentBlockIt->getSecond();
-    auto parentBlockExecutions = getNumberOfExecutions(parentBlockInfo);
-
-    // We stumbled upon an operation with unknown number of executions.
-    if (!parentBlockExecutions.hasValue())
-      return None;
-
-    // Number of block executions is a product of all parent blocks executions.
-    numberOfExecutions *= *parentBlockExecutions;
-    parentOp = parentOp->getParentOp();
-
-    assert(parentOp != nullptr);
-  }
-
-  return numberOfExecutions;
-}
-
-void NumberOfExecutions::printBlockExecutions(
-    raw_ostream &os, Region *perEntryOfThisRegion) const {
-  unsigned blockId = 0;
-
-  operation->walk<WalkOrder::PreOrder>([&](Block *block) {
-    llvm::errs() << "Block: " << blockId++ << "\n";
-    llvm::errs() << "Number of executions: ";
-    if (auto n = getNumberOfExecutions(block, perEntryOfThisRegion))
-      llvm::errs() << *n << "\n";
-    else
-      llvm::errs() << "<unknown>\n";
-  });
-}
-
-void NumberOfExecutions::printOperationExecutions(
-    raw_ostream &os, Region *perEntryOfThisRegion) const {
-  operation->walk<WalkOrder::PreOrder>([&](Block *block) {
-    block->walk([&](Operation *operation) {
-      // Skip the operation that was used to build the analysis.
-      if (operation == this->operation)
-        return;
-
-      llvm::errs() << "Operation: " << operation->getName() << "\n";
-      llvm::errs() << "Number of executions: ";
-      if (auto n = getNumberOfExecutions(operation, perEntryOfThisRegion))
-        llvm::errs() << *n << "\n";
-      else
-        llvm::errs() << "<unknown>\n";
-    });
-  });
-}
-
-//===----------------------------------------------------------------------===//
-// BlockNumberOfExecutionsInfo
-//===----------------------------------------------------------------------===//
-
-BlockNumberOfExecutionsInfo::BlockNumberOfExecutionsInfo(
-    Block *block, Optional<int64_t> numberOfRegionInvocations,
-    Optional<int64_t> numberOfBlockExecutions)
-    : block(block), numberOfRegionInvocations(numberOfRegionInvocations),
-      numberOfBlockExecutions(numberOfBlockExecutions) {}
-
-Optional<int64_t> BlockNumberOfExecutionsInfo::getNumberOfExecutions() const {
-  if (numberOfRegionInvocations && numberOfBlockExecutions)
-    return *numberOfRegionInvocations * *numberOfBlockExecutions;
-  return None;
-}
-
-Optional<int64_t> BlockNumberOfExecutionsInfo::getNumberOfExecutions(
-    int64_t numberOfRegionInvocations) const {
-  if (numberOfBlockExecutions)
-    return numberOfRegionInvocations * *numberOfBlockExecutions;
-  return None;
-}

mlir/lib/Dialect/Async/IR/Async.cpp

 }
 
 //===----------------------------------------------------------------------===//
 /// ExecuteOp
 //===----------------------------------------------------------------------===//
 
 constexpr char kOperandSegmentSizesAttr[] = "operand_segment_sizes";
 
-void ExecuteOp::getNumRegionInvocations(
-    ArrayRef<Attribute>, SmallVectorImpl<int64_t> &countPerRegion) {
-  assert(countPerRegion.empty());
-  countPerRegion.push_back(1);
-}
-
 OperandRange ExecuteOp::getSuccessorEntryOperands(unsigned index) {
   assert(index == 0 && "invalid region index");
   return operands();
 }
 
 void ExecuteOp::getSuccessorRegions(Optional<unsigned> index,
                                     ArrayRef<Attribute>,
                                     SmallVectorImpl<RegionSuccessor> &regions) {

mlir/lib/Dialect/SCF/SCF.cpp

void ForOp::getSuccessorRegions(Optional<unsigned> index,
   }
 
   // Otherwise, the loop may branch back to itself or the parent operation.
   assert(index.getValue() == 0 && "expected loop region");
   regions.push_back(RegionSuccessor(&getLoopBody(), getRegionIterArgs()));
   regions.push_back(RegionSuccessor(getResults()));
 }
 
-void ForOp::getNumRegionInvocations(ArrayRef<Attribute> operands,
-                                    SmallVectorImpl<int64_t> &countPerRegion) {
-  assert(countPerRegion.empty());
-  countPerRegion.resize(1);
-
-  auto lb = operands[0].dyn_cast_or_null<IntegerAttr>();
-  auto ub = operands[1].dyn_cast_or_null<IntegerAttr>();
-  auto step = operands[2].dyn_cast_or_null<IntegerAttr>();
-
-  // Loop bounds are not known statically.
-  if (!lb || !ub || !step || step.getValue().getSExtValue() == 0) {
-    countPerRegion[0] = kUnknownNumRegionInvocations;
-    return;
-  }
-
-  countPerRegion[0] =
-      ceilDiv(ub.getValue().getSExtValue() - lb.getValue().getSExtValue(),
-              step.getValue().getSExtValue());
-}
-
 LoopNest mlir::scf::buildLoopNest(
     OpBuilder &builder, Location loc, ValueRange lbs, ValueRange ubs,
     ValueRange steps, ValueRange iterArgs,
     function_ref<ValueVector(OpBuilder &, Location, ValueRange, ValueRange)>
         bodyBuilder) {
   assert(lbs.size() == ubs.size() &&
          "expected the same number of lower and upper bounds");
   assert(lbs.size() == steps.size() &&
if (elseRegion)
       regions.push_back(RegionSuccessor(elseRegion));
     return;
   }
 
   // Add the successor regions using the condition.
   regions.push_back(RegionSuccessor(condition ? &getThenRegion() : elseRegion));
 }
 
-/// If the condition is a constant, returns 1 for the executed block and 0 for
-/// the other. Otherwise, returns `kUnknownNumRegionInvocations` for both
-/// successors.
-void IfOp::getNumRegionInvocations(ArrayRef<Attribute> operands,
-                                   SmallVectorImpl<int64_t> &countPerRegion) {
-  if (auto condAttr = operands.front().dyn_cast_or_null<IntegerAttr>()) {
-    // If the condition is true, `then` is executed once and `else` zero times,
-    // and vice-versa.
-    bool cond = condAttr.getValue().isOneValue();
-    countPerRegion.assign(1, cond ? 1 : 0);
-    countPerRegion.push_back(cond ? 0 : 1);
-  } else {
-    // Non-constant condition: unknown invocations for both successors.
-    countPerRegion.assign(2, kUnknownNumRegionInvocations);
-  }
-}
-
 LogicalResult IfOp::fold(ArrayRef<Attribute> operands,
                          SmallVectorImpl<OpFoldResult> &results) {
   // if (!c) then A() else B() -> if c then B() else A()
   if (getElseRegion().empty())
     return failure();
 
   arith::XOrIOp xorStmt = getCondition().getDefiningOp<arith::XOrIOp>();
   if (!xorStmt)

mlir/lib/Interfaces/ControlFlowInterfaces.cpp

detail::verifyBranchSuccessorOperands(Operation *op, unsigned succNo,
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // RegionBranchOpInterface
 //===----------------------------------------------------------------------===//
 
-// A constant value to represent unknown number of region invocations.
-const int64_t mlir::kUnknownNumRegionInvocations = -1;
-
 /// Verify that types match along all region control flow edges originating from
 /// `sourceNo` (region # if source is a region, llvm::None if source is parent
 /// op). `getInputsTypesForRegion` is a function that returns the types of the
 /// inputs that flow from `sourceIndex' to the given region, or llvm::None if
 /// the exact type match verification is not necessary (e.g., if the Op verifies
 /// the match itself).
 static LogicalResult
 verifyTypesAlongAllEdges(Operation *op, Optional<unsigned> sourceNo,

mlir/test/Analysis/test-number-of-block-executions.mlir

-// RUN: mlir-opt %s                                                            \
-// RUN:     -test-print-number-of-block-executions                             \
-// RUN:     -split-input-file 2>&1                                             \
-// RUN:   | FileCheck %s --dump-input=always
-
-// CHECK-LABEL: Number of executions: empty
-func @empty() {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: sequential
-func @sequential() {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  br ^bb1
-^bb1:
-  // CHECK: Block: 1
-  // CHECK-NEXT: Number of executions: 1
-  br ^bb2
-^bb2:
-  // CHECK: Block: 2
-  // CHECK-NEXT: Number of executions: 1
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: conditional
-func @conditional(%cond : i1) {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  br ^bb1
-^bb1:
-  // CHECK: Block: 1
-  // CHECK-NEXT: Number of executions: 1
-  cond_br %cond, ^bb2, ^bb3
-^bb2:
-  // CHECK: Block: 2
-  // CHECK-NEXT: Number of executions: <unknown>
-  br ^bb4
-^bb3:
-  // CHECK: Block: 3
-  // CHECK-NEXT: Number of executions: <unknown>
-  br ^bb4
-^bb4:
-  // CHECK: Block: 4
-  // CHECK-NEXT: Number of executions: <unknown>
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: loop
-func @loop(%cond : i1) {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  br ^bb1
-^bb1:
-  // CHECK: Block: 1
-  // CHECK-NEXT: Number of executions: <unknown>
-  br ^bb2
-^bb2:
-  // CHECK: Block: 2
-  // CHECK-NEXT: Number of executions: <unknown>
-  br ^bb3
-^bb3:
-  // CHECK: Block: 3
-  // CHECK-NEXT: Number of executions: <unknown>
-  cond_br %cond, ^bb1, ^bb4
-^bb4:
-  // CHECK: Block: 4
-  // CHECK-NEXT: Number of executions: <unknown>
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: scf_if_dynamic_branch
-func @scf_if_dynamic_branch(%cond : i1) {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  scf.if %cond {
-    // CHECK: Block: 1
-    // CHECK-NEXT: Number of executions: <unknown>
-  } else {
-    // CHECK: Block: 2
-    // CHECK-NEXT: Number of executions: <unknown>
-  }
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: async_execute
-func @async_execute() {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  async.execute {
-   // CHECK: Block: 1
-   // CHECK-NEXT: Number of executions: 1
-    async.yield
-  }
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: async_execute_with_scf_if
-func @async_execute_with_scf_if(%cond : i1) {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  async.execute {
-    // CHECK: Block: 1
-    // CHECK-NEXT: Number of executions: 1
-    scf.if %cond {
-    // CHECK: Block: 2
-    // CHECK-NEXT: Number of executions: <unknown>
-    } else {
-    // CHECK: Block: 3
-    // CHECK-NEXT: Number of executions: <unknown>
-    }
-    async.yield
-  }
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: scf_for_constant_bounds
-func @scf_for_constant_bounds() {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  %c0 = arith.constant 0 : index
-  %c1 = arith.constant 1 : index
-  %c2 = arith.constant 2 : index
-
-  scf.for %i = %c0 to %c2 step %c1 {
-    // CHECK: Block: 1
-    // CHECK-NEXT: Number of executions: 2
-  }
-
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: propagate_parent_num_executions
-func @propagate_parent_num_executions() {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  %c0 = arith.constant 0 : index
-  %c1 = arith.constant 1 : index
-  %c2 = arith.constant 2 : index
-
-  scf.for %i = %c0 to %c2 step %c1 {
-    // CHECK: Block: 1
-    // CHECK-NEXT: Number of executions: 2
-    async.execute {
-      // CHECK: Block: 2
-      // CHECK-NEXT: Number of executions: 2
-      async.yield
-    }
-  }
-
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: clear_num_executions
-func @clear_num_executions(%step : index) {
-  // CHECK: Block: 0
-  // CHECK-NEXT: Number of executions: 1
-  %c0 = arith.constant 0 : index
-  %c2 = arith.constant 2 : index
-
-  scf.for %i = %c0 to %c2 step %step {
-    // CHECK: Block: 1
-    // CHECK-NEXT: Number of executions: <unknown>
-    async.execute {
-      // CHECK: Block: 2
-      // CHECK-NEXT: Number of executions: <unknown>
-      async.yield
-    }
-  }
-
-  return
-}

mlir/test/Analysis/test-number-of-operation-executions.mlir

-// RUN: mlir-opt %s                                                            \
-// RUN:     -test-print-number-of-operation-executions                         \
-// RUN:     -split-input-file 2>&1                                             \
-// RUN:   | FileCheck %s
-
-// CHECK-LABEL: Number of executions: empty
-func @empty() {
-  // CHECK: Operation: std.return
-  // CHECK-NEXT: Number of executions: 1
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: propagate_parent_num_executions
-func @propagate_parent_num_executions() {
-  // CHECK: Operation: arith.constant
-  // CHECK-NEXT: Number of executions: 1
-  %c0 = arith.constant 0 : index
-  // CHECK: Operation: arith.constant
-  // CHECK-NEXT: Number of executions: 1
-  %c1 = arith.constant 1 : index
-  // CHECK: Operation: arith.constant
-  // CHECK-NEXT: Number of executions: 1
-  %c2 = arith.constant 2 : index
-
-  // CHECK-DAG: Operation: scf.for
-  // CHECK-NEXT: Number of executions: 1
-  scf.for %i = %c0 to %c2 step %c1 {
-    // CHECK-DAG: Operation: async.execute
-    // CHECK-NEXT: Number of executions: 2
-    async.execute {
-      // CHECK-DAG: Operation: async.yield
-      // CHECK-NEXT: Number of executions: 2
-      async.yield
-    }
-  }
-
-  return
-}
-
-// -----
-
-// CHECK-LABEL: Number of executions: clear_num_executions
-func @clear_num_executions(%step : index) {
-  // CHECK: Operation: arith.constant
-  // CHECK-NEXT: Number of executions: 1
-  %c0 = arith.constant 0 : index
-  // CHECK: Operation: arith.constant
-  // CHECK-NEXT: Number of executions: 1
-  %c2 = arith.constant 2 : index
-
-  // CHECK: Operation: scf.for
-  // CHECK-NEXT: Number of executions: 1
-  scf.for %i = %c0 to %c2 step %step {
-    // CHECK: Operation: async.execute
-    // CHECK-NEXT: Number of executions: <unknown>
-    async.execute {
-      // CHECK: Operation: async.yield
-      // CHECK-NEXT: Number of executions: <unknown>
-      async.yield
-    }
-  }
-
-  return
-}

mlir/test/lib/Analysis/CMakeLists.txt

 # Exclude tests from libMLIR.so
 add_mlir_library(MLIRTestAnalysis
   TestAliasAnalysis.cpp
   TestCallGraph.cpp
   TestLiveness.cpp
   TestMatchReduction.cpp
   TestMemRefBoundCheck.cpp
   TestMemRefDependenceCheck.cpp
   TestMemRefStrideCalculation.cpp
-  TestNumberOfExecutions.cpp
   TestSlice.cpp
 
 
   EXCLUDE_FROM_LIBMLIR
 
   LINK_LIBS PUBLIC
   MLIRAffine
   MLIRAnalysis

mlir/test/lib/Analysis/TestNumberOfExecutions.cpp

-//===- TestNumberOfExecutions.cpp - Test number of executions analysis ----===//
-//
-// 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 test passes for constructing and resolving number of
-// executions information.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Analysis/NumberOfExecutions.h"
-#include "mlir/Pass/Pass.h"
-
-using namespace mlir;
-
-namespace {
-
-struct TestNumberOfBlockExecutionsPass
-    : public PassWrapper<TestNumberOfBlockExecutionsPass, FunctionPass> {
-  StringRef getArgument() const final {
-    return "test-print-number-of-block-executions";
-  }
-  StringRef getDescription() const final {
-    return "Print the contents of a constructed number of executions analysis "
-           "for "
-           "all blocks.";
-  }
-  void runOnFunction() override {
-    llvm::errs() << "Number of executions: " << getFunction().getName() << "\n";
-    getAnalysis<NumberOfExecutions>().printBlockExecutions(
-        llvm::errs(), &getFunction().getBody());
-  }
-};
-
-struct TestNumberOfOperationExecutionsPass
-    : public PassWrapper<TestNumberOfOperationExecutionsPass, FunctionPass> {
-  StringRef getArgument() const final {
-    return "test-print-number-of-operation-executions";
-  }
-  StringRef getDescription() const final {
-    return "Print the contents of a constructed number of executions analysis "
-           "for "
-           "all operations.";
-  }
-  void runOnFunction() override {
-    llvm::errs() << "Number of executions: " << getFunction().getName() << "\n";
-    getAnalysis<NumberOfExecutions>().printOperationExecutions(
-        llvm::errs(), &getFunction().getBody());
-  }
-};
-
-} // namespace
-
-namespace mlir {
-namespace test {
-void registerTestNumberOfBlockExecutionsPass() {
-  PassRegistration<TestNumberOfBlockExecutionsPass>();
-}
-
-void registerTestNumberOfOperationExecutionsPass() {
-  PassRegistration<TestNumberOfOperationExecutionsPass>();
-}
-} // namespace test
-} // namespace mlir

mlir/tools/mlir-opt/mlir-opt.cpp

 void registerTestLoopFusion();
 void registerTestLoopMappingPass();
 void registerTestLoopUnrollingPass();
 void registerTestMatchReductionPass();
 void registerTestMathAlgebraicSimplificationPass();
 void registerTestMathPolynomialApproximationPass();
 void registerTestMemRefDependenceCheck();
 void registerTestMemRefStrideCalculation();
-void registerTestNumberOfBlockExecutionsPass();
-void registerTestNumberOfOperationExecutionsPass();
 void registerTestOpaqueLoc();
 void registerTestPadFusion();
 void registerTestPDLByteCodePass();
 void registerTestPreparationPassWithAllowedMemrefResults();
 void registerTestRecursiveTypesPass();
 void registerTestSCFUtilsPass();
 void registerTestSliceAnalysisPass();
 void registerTestVectorLowerings();
#endif
   mlir::test::registerTestLoopFusion();
   mlir::test::registerTestLoopMappingPass();
   mlir::test::registerTestLoopUnrollingPass();
   mlir::test::registerTestMatchReductionPass();
   mlir::test::registerTestMathAlgebraicSimplificationPass();
   mlir::test::registerTestMathPolynomialApproximationPass();
   mlir::test::registerTestMemRefDependenceCheck();
   mlir::test::registerTestMemRefStrideCalculation();
-  mlir::test::registerTestNumberOfBlockExecutionsPass();
-  mlir::test::registerTestNumberOfOperationExecutionsPass();
   mlir::test::registerTestOpaqueLoc();
   mlir::test::registerTestPadFusion();
   mlir::test::registerTestPDLByteCodePass();
   mlir::test::registerTestRecursiveTypesPass();
   mlir::test::registerTestSCFUtilsPass();
   mlir::test::registerTestSliceAnalysisPass();
   mlir::test::registerTestVectorLowerings();
 }

mlir/unittests/Dialect/CMakeLists.txt

 add_mlir_unittest(MLIRDialectTests
   BroadcastShapeTest.cpp
 )
 target_link_libraries(MLIRDialectTests
   PRIVATE
   MLIRIR
   MLIRDialect)
 
 add_subdirectory(Quant)
-add_subdirectory(SCF)
 add_subdirectory(SparseTensor)
 add_subdirectory(SPIRV)
 add_subdirectory(Utils)

mlir/unittests/Dialect/SCF/CMakeLists.txt

-add_mlir_unittest(MLIRSCFTests
-  SCFOps.cpp
-  )
-target_link_libraries(MLIRSCFTests
-  PRIVATE
-  MLIRIR
-  MLIRParser
-  MLIRSCF
-  MLIRStandard
-  )

mlir/unittests/Dialect/SCF/SCFOps.cpp

-//===- SCFOps.cpp - SCF Op Unit Tests -------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/StandardOps/IR/Ops.h"
-#include "mlir/Parser.h"
-#include "gtest/gtest.h"
-
-using namespace mlir;
-
-namespace {
-class SCFOpsTest : public testing::Test {
-public:
-  SCFOpsTest() {
-    context.getOrLoadDialect<scf::SCFDialect>();
-    context.getOrLoadDialect<StandardOpsDialect>();
-  }
-
-protected:
-  MLIRContext context;
-};
-
-TEST_F(SCFOpsTest, IfOpNumRegionInvocations) {
-  const char *const code = R"mlir(
-func @test(%cond : i1) -> () {
-  scf.if %cond {
-    scf.yield
-  } else {
-    scf.yield
-  }
-  return
-}
-)mlir";
-  Builder builder(&context);
-
-  auto module = parseSourceString(code, &context);
-  ASSERT_TRUE(module);
-  scf::IfOp op;
-  module->walk([&](scf::IfOp ifOp) { op = ifOp; });
-  ASSERT_TRUE(op);
-
-  SmallVector<int64_t> countPerRegion;
-  op.getNumRegionInvocations({Attribute()}, countPerRegion);
-  EXPECT_EQ(countPerRegion.size(), 2u);
-  EXPECT_EQ(countPerRegion[0], kUnknownNumRegionInvocations);
-  EXPECT_EQ(countPerRegion[1], kUnknownNumRegionInvocations);
-
-  countPerRegion.clear();
-  op.getNumRegionInvocations(
-      {builder.getIntegerAttr(builder.getI1Type(), true)}, countPerRegion);
-  EXPECT_EQ(countPerRegion.size(), 2u);
-  EXPECT_EQ(countPerRegion[0], 1);
-  EXPECT_EQ(countPerRegion[1], 0);
-
-  countPerRegion.clear();
-  op.getNumRegionInvocations(
-      {builder.getIntegerAttr(builder.getI1Type(), false)}, countPerRegion);
-  EXPECT_EQ(countPerRegion.size(), 2u);
-  EXPECT_EQ(countPerRegion[0], 0);
-  EXPECT_EQ(countPerRegion[1], 1);
-}
-} // end anonymous namespace