private:
  LogicalResult matchAndRewrite(TF::PartitionedCallOp call_op,
                                PatternRewriter& rewriter) const override {
    StringRef function_name =
        mlir::cast<FlatSymbolRefAttr>(call_op.getFAttr()).getValue();
    if (!function_name.starts_with("composite_") ||
        !call_op->hasAttr(kQuantTraitAttrName)) {
      return failure();
    }

static void clobber_stack() {
	volatile char a[1024];
	int i;
	for(i = 0; i < sizeof a; i++)
		a[i] = 0xff;
}

static int call_go() {
	GoString s;
	s.p = "test";
	s.n = 4;
	return issue5548FromC(s, 42);
}

int issue5548_in_c() {
	clobber_stack();
	return call_go();

      int current_num_elements =
          mlir::cast<ShapedType>(call_op.getOperand(idx).getType())
              .getNumElements();
      if (current_num_elements < min_num_elements_for_weights_) {
        call_op.emitRemark("Quantization is skipped for ")
            << call_op->getName().getStringRef().str() << " because it has "
            << current_num_elements

                                      TF_Status* status) {
  tensorflow::ImmediateOpPtr call_op;
  absl::Span<tensorflow::AbstractTensorHandle* const> input_span(
      reinterpret_cast<tensorflow::AbstractTensorHandle**>(
          tensorflow::unwrap(inputs)),
      static_cast<size_t>(num_inputs));
  status->status = tensorflow::unwrap(func)->MakeCallOp(input_span, &call_op);
  if (!status->status.ok()) {
    return nullptr;
  }

  tensorflow::ImmediateOpPtr call_op;
  absl::Span<tensorflow::AbstractTensorHandle* const> input_span(
      reinterpret_cast<tensorflow::AbstractTensorHandle**>(
          tensorflow::unwrap(inputs)),
      static_cast<size_t>(num_inputs));
  status->status = tensorflow::unwrap(func)->MakeCallOp(input_span, &call_op);
  if (!status->status.ok()) {
    return nullptr;
  }

constexpr float kRequantCost = 2.0;

// TODO(renjieliu): Ideally this should consider different kinds of SOCs as
// well.

// Get total bytes transferred.
int64_t GetTransferredTensorBytes(func::CallOp from_graph,
                                  func::CallOp to_graph) {
  int64_t total_size_transferred = 0;
  for (auto input : to_graph.getOperands()) {
    Operation* input_op = input.getDefiningOp();

                      const std::string& to_hardware_str,
                      func::CallOp from_graph, func::CallOp to_graph);

// Get the cross quantization/dequantization boundary cost.
float GetQuantDequantCost(InferenceType from_inference_type,
                          InferenceType to_inference_type,
                          func::CallOp from_graph, func::CallOp to_graph);

}  // namespace tac
}  // namespace TFL
}  // namespace mlir

    if (method.ok() && method->has_static_range_ptq()) return true;
  }

  TF::PartitionedCallOp call_op = dyn_cast_or_null<TF::PartitionedCallOp>(op);
  return call_op && call_op->hasAttrOfType<StringAttr>(kQuantTraitAttrName) &&
         call_op->getAttrOfType<StringAttr>(kQuantTraitAttrName).getValue() ==
             llvm::StringRef(

  bool IsCompositeFunction(TF::PartitionedCallOp call_op) const {
    if (!call_op->hasAttr(kQuantTraitAttrName)) {
      return false;
    }

    const auto f_attr = call_op.getFAttr().dyn_cast<FlatSymbolRefAttr>();
    if (!f_attr || !f_attr.getValue().starts_with("composite_")) {
      return false;
    }

    bool has_quantized_types = false;
    for (Value input : call_op.getArgs()) {

  return method.has_weight_only_ptq();
}

bool IsWeightOnlyQuantizableOp(const Operation& op) {
  if (auto call_op = dyn_cast<TF::XlaCallModuleOp>(op)) {
    StringRef entry_function_name = GetEntryFunctionName(call_op);
    absl::StatusOr<Method> quantization_method = GetQuantizationMethod(call_op);
    return ContainsConvOrDot(entry_function_name) && quantization_method.ok() &&
           quantization_method->has_weight_only_ptq();