auto dq_op = dyn_cast_or_null<DequantizeOp>(value_op);
      if (dq_op) {
        Type output_type = dq_op.getInput().getType();
        auto qtype = quant::QuantizedType::getQuantizedElementType(output_type);
        if (qtype == quant::QuantizedType::getQuantizedElementType(ref_qtype)) {
          // Same quantization parameters, remove it.
          builder.setInsertionPoint(assign_variable_op);

      auto input_type = input.get().getType();
      if (IsQI8Type(input_type) || IsQUI8Type(input_type) ||
          IsQI32Type(input_type)) {
        auto dequantized_input_type =
            mlir::quant::QuantizedType::castToExpressedType(input_type);
        builder->setInsertionPoint(op);
        auto dequantize_op = builder->create<TFL::DequantizeOp>(
            op->getLoc(), dequantized_input_type, input.get());

    if (arg.hasOneUse() && llvm::isa<QuantizeOp>(*arg.user_begin())) {
      auto quantize_op = llvm::cast<QuantizeOp>(*arg.user_begin());
      auto quantize_output = quantize_op.getOutput();
      auto current_type = quant::QuantizedType::getQuantizedElementType(
                              quantize_output.getType())
                              .getStorageType();
      if (current_type == input_type) {  // int8 == int8

// CHECK: return %[[CALL]] : tensor<1x3xf32>

// -----

// Test that q/dq pair with per-channel quantization parameter is inserted
// between constant and XlaCallModule op with `weight_only_ptq` method of
// `quatized_type` without specified quantization dimension and function name
// containing conv.

module attributes {tf_saved_model.semantics} {

    if (complex_element_type.isF32() || complex_element_type.isF64())
      return true;
  }
  // Check quantized types.
  if (auto quant_type = element_type.dyn_cast<mlir::quant::QuantizedType>()) {
    // TFLite supports QI16, QI32, QI8, and QUI8
    if ((quant_type.getStorageTypeIntegralWidth() == 16 &&
         quant_type.isSigned()) ||
        quant_type.getStorageTypeIntegralWidth() == 8 ||

}

quant::QuantParams DefaultQuantParamsPass::GetQuantParamsForBias(
    Operation *op, int bias, const std::vector<int> &non_biases,
    quant::AccumulatorScaleFunc func) {
  std::vector<quant::QuantizedType> non_bias_types;
  non_bias_types.reserve(non_biases.size());
  for (int non_bias : non_biases) {
    Operation *non_bias_define = op->getOperand(non_bias).getDefiningOp();

namespace func {
class FuncOp;
}  // namespace func

namespace quantfork {

/// Creates a pass that converts quantization simulation operations (i.e.
/// FakeQuant and those like it) to casts into/out of supported QuantizedTypes.
std::unique_ptr<OperationPass<func::FuncOp>> createConvertSimulatedQuantPass();

/// Creates a pass that converts constants followed by a qbarrier to a
/// constant whose value is quantized. This is typically one of the last

#include "mlir/IR/Types.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace mlir::quantfork {

// Performs type conversion from an arbitrary input type to a type
// that is expressed by a QuantizedType.
//
// This handles cases where the inputType is a supported primitive type
// (i.e. f32, bf16, etc) or a vector/tensor type based on a supported
// elemental type.
//

    if (splat_elements_attr.getNumElements() == 1) {
      return;
    }
    auto element_type = splat_elements_attr.getType().getElementType();
    if (mlir::isa<ComplexType>(element_type) ||
        mlir::isa<quant::QuantizedType>(element_type)) {
      return;
    }
    op_builder->setInsertionPoint(const_op);
    Value scalar = op_builder->create<mhlo::ConstantOp>(
        const_op->getLoc(),
        DenseElementsAttr::get(

    return ExpressedToQuantizedConverter{input_type, input_type};
  // Unsupported.
  return ExpressedToQuantizedConverter{input_type, nullptr};
}

Type ExpressedToQuantizedConverter::convert(
    quant::QuantizedType elemental_type) const {
  assert(expressed_type && "convert() on unsupported conversion");
  if (auto tensor_type = dyn_cast<RankedTensorType>(input_type))
    return RankedTensorType::get(tensor_type.getShape(), elemental_type);