StringRef getDescription() const final {
    return "Fuses MHLO binary element-wise ops and convolution op";
  }

  void runOnOperation() override {
    RewritePatternSet patterns(&getContext());
    patterns.add<FuseMhloMulAndConvolutionPattern>(&getContext());
    if (failed(applyPatternsAndFoldGreedily(getOperation(),
                                            std::move(patterns)))) {

                                     true>;

// TODO(fengliuai): add the support of the tf.QuantizeAndDequantize*
// legalization.

void LegalizeTFToQuant::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto func = getOperation();
  auto *ctx = func.getContext();
  patterns.add<PreparePerTensorFakeQuant, PreparePerChannelFakeQuant>(ctx);

    rewriter.modifyOpInPlace(
        op, [&]() { op->getOpOperand(i).set(broadcast.getInput()); });
    changed = true;
  }
  return success(changed);
}

void BroadcastFoldPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto func = getOperation();

  patterns.add<ConvertResultsBroadcastableShapeOp>(func.getContext());
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

      }
      changed = true;
    }
    return changed ? success() : failure();
  }
};

void PropagateQuantizeType::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto module_op = getOperation();
  MLIRContext* ctx = &getContext();

  patterns.add<PropagateDequantizeOpIfAllowed>(ctx);
  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

    // return type should be updated.
    UpdateFuncType(parent_op);

    return success();
  }
};

void OptimizeFunctionalOpsPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());

  patterns.add<FoldIfOp>(&getContext());

  ModuleOp module = getOperation();
  (void)applyPatternsAndFoldGreedily(module, std::move(patterns));
}
}  // namespace

  virtual double GetHardwareSwitchingCost(const TargetHardware* from,
                                          size_t buffer_size) const = 0;

  // Returns a list of all patterns to apply for this hardware.
  virtual mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const = 0;

  // Returns TypeId for the provided hardware.
  // Usually should be something like mlir::TypeID::get<MyType>()
  virtual mlir::TypeID GetTypeId() const = 0;

#include "tensorflow/compiler/mlir/tensorflow/transforms/generated_decompose_resource_ops.inc"
}  // namespace

void PopulateDecomposeResourceOpsPatterns(MLIRContext *context,
                                          RewritePatternSet *patterns) {
  patterns->add<DecomposeRngReadAndSkipOp>(context);
  populateWithGenerated(*patterns);
}

}  // namespace TF

      !quant_specs_.disable_infer_tensor_range;

  // During the legalization, unsigned quantized type is used, so we have to
  // convert all of them to signed.
  RewritePatternSet patterns(ctx);
  populateWithGenerated(patterns);
  patterns.add<quant::ConvertUnsignedToSigned<quantfork::QuantizeCastOp>>(ctx);
  // Convert quant stats to int8 quantization parameters.

    rewriter.replaceOp(reduce_op, orig_reduce_op);
    return success();
  }
};

void TransposeCommuteOpsPass::runOnOperation() {
  auto* ctx = &getContext();

  RewritePatternSet patterns(ctx);
  patterns.add<TransposeCommuteWithPad, TransposeCommuteWithReduceWindow>(ctx);
  if (failed(
          applyPatternsAndFoldGreedily(getOperation(), std::move(patterns)))) {
    return signalPassFailure();

 private:
  void runOnOperation() override;
};

void FoldConstantTransposePass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  patterns.add<FoldTransposedConstantOp>(&ctx);
  if (failed(applyPatternsAndFoldGreedily(func_op, std::move(patterns)))) {
    func_op.emitError("Failed to fold constant->transpose pattern.");