}
		// Handle multi-byte Unicode.
		r, n := utf8.DecodeRune(in[i:])
		out = utf8.AppendRune(out, foldRune(r))
		i += n
	}
	return out
}

// foldRune is returns the smallest rune for all runes in the same fold set.
func foldRune(r rune) rune {
	for {
		r2 := unicode.SimpleFold(r)
		if r2 <= r {
			return r2
		}
		r = r2
	}

// Test for partial folding: only fold i32 constants.
// RUN: tac-opt-all-backends -tfl-fold-constants-to-subgraph='fold-all-constants=false' %s -split-input-file -verify-diagnostics | FileCheck --check-prefix=PARTIAL %s

// Test for fold all constants.
// RUN: tac-opt-all-backends -tfl-fold-constants-to-subgraph='fold-all-constants=true' %s -split-input-file -verify-diagnostics | FileCheck --check-prefix=ALL %s

module {

// RUN: tf-opt -tf-broadcast-fold %s | FileCheck %s

// CHECK-LABEL: @broadcast_mul0
func.func @broadcast_mul0(%arg0: tensor<5x7xf32>, %arg1: tensor<7xf32>) -> tensor<5x7xf32> {
  %cst = arith.constant dense<[5, 7]> : tensor<2xi32>
  %0 = "tf.BroadcastTo"(%arg1, %cst) : (tensor<7xf32>, tensor<2xi32>) -> tensor<5x7xf32>
  %1 = "tf.Mul"(%arg0, %0) : (tensor<5x7xf32>, tensor<5x7xf32>) -> tensor<5x7xf32>
  func.return %1 : tensor<5x7xf32>

  // CHECK: %[[RESULT:.*]] = "tf.Mul"(%arg0, %[[CONST]]) : (tensor<1x6x8x1xf32>, tensor<f32>) -> tensor<1x6x8x1xf32>
  // CHECK: return %[[RESULT]] : tensor<1x6x8x1xf32>
}

// Do not fold if the op doesn't follow the constant folding policy. It doesn't
// fold if the  total result size is large (>1 MB) and more than 2 times the
// size of operands.

// CHECK-LABEL: DontFoldTile
func.func @DontFoldTile() -> (tensor<64x10000xi32>) {

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

// This pass folds the tf.Identity op if the operation has the same device as
// its operand.

#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Pass/PassManager.h"
#include "mlir/Transforms/DialectConversion.h"

Jonathan Amsterdam <******@****.***> 1700059801 -0500

}

class FoldBroadcastPass
    : public PassWrapper<FoldBroadcastPass, OperationPass<func::FuncOp>> {
 public:
  StringRef getArgument() const final { return "constant-fold-broadcast-pass"; }
  StringRef getDescription() const final {
    return "Constant folds BroadcastInDimOp before binary elementwise ops";
  }
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {}

  void runOnOperation() override {

Christian Sigg <******@****.***> 1714640622 -0700

  ];
}

def FoldConstantTransposePass : Pass<"stablehlo-fold-constant-transpose", "mlir::func::FuncOp"> {
  let summary = "Folds stablehlo.constant -> stablehlo.transpose patterns.";
  let description = [{
    Finds patterns where a `stablehlo.constant` is directly followed by a
    `stablehlo.transpose` and folds them into a single `stablehlo.constant`.

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FoldConstantsToSubgraphPass)

  llvm::StringRef getArgument() const final {
    return "tfl-fold-constants-to-subgraph";
  }
  llvm::StringRef getDescription() const final {
    return "Fold constants into each subgraph.";
  }
  FoldConstantsToSubgraphPass() = default;
  FoldConstantsToSubgraphPass(const FoldConstantsToSubgraphPass& other) {