expressions.push_back(expr);

    if (!tensorflow::DataTypeCanUseMemcpy(expr.dtype())) {
      return op_->emitRemark()
             << "skipping legalization due to unsupported type "
             << operand.getType();
    }

    auto shape_or = expr.GetShape();
    if (!shape_or.ok()) {
      return op_->emitRemark()
             << "failed to get shape for expression. " << expr.HumanString();
    }

        op->emitRemark("Predecessors: ")
            << "{" << join_ids(analysis.DirectControlPredecessors(op)) << "}";
      }
      if (!analysis.DirectControlSuccessors(op).empty()) {
        op->emitRemark("Successors: ")
            << "{" << join_ids(analysis.DirectControlSuccessors(op)) << "}";
      }
      if (llvm::isa<func::ReturnOp>(op)) {
        op->emitRemark("Sinks: ")

  if (!var_handle_op) {
    assign_var_op->emitRemark(
        "Operand idx 0 is not a tf.VarHandleOp. The initializing tensor is not "
        "saved to checkpoint.");
    return "";
  }

  auto assigned_value_operand = assign_var_op.getOperand(1);
  auto const_op =
      llvm::dyn_cast<mlir::TF::ConstOp>(assigned_value_operand.getDefiningOp());
  if (!const_op) {
    assign_var_op->emitRemark(

                          int count,
                          const SmallVector<Operation*>& filtered_ops) {
  emitRemark(module_loc) << llvm::formatv("Tac filter ({0}): {1}", count,
                                          TacFilterToString(tac_filter));
  if (filtered_ops.empty()) {
    emitRemark(module_loc) << llvm::formatv(
        "Tac filter ({0}) specified but not applied to any op", count);
    return;
  }

          InFlightDiagnostic diag = op->emitRemark("Region #")
                                    << region.getRegionNumber() << ", Arg #"
                                    << region_arg.getArgNumber();
          print_aliases(diag, region_arg);
        }
      }

      for (auto result : TF::filter_resources(op->getResults())) {
        InFlightDiagnostic diag = op->emitRemark("Result #")

  void runOnOperation() override {
    auto module = getOperation();
    TensorArraySideEffectAnalysis tensor_array_side_effect_analysis(module);

    for (auto func_op : module.getOps<mlir::func::FuncOp>()) {
      func_op.emitRemark() << "HasAtMostTensorArrayEffect: "
                           << tensor_array_side_effect_analysis
                                  .HasAtMostTensorArrayEffect(func_op);
    }
  }
};

  }
  void runOnOperation() override {
    const auto& cost_analysis = getAnalysis<CostAnalysis>();

    auto func_op = getOperation();
    for (auto& op : func_op.front()) {
      op.emitRemark() << "Cost: " << cost_analysis.GetCost(&op);
    }
  }
};

static mlir::PassRegistration<TestCostAnalysis> pass;

}  // namespace tfrt_compiler

  module_op.getRegion().walk([&analyzer](Operation* op) {
    if (auto var_handle_op = dyn_cast<TF::VarHandleOp>(op)) {
      const ResourceKey resource_key = GetResourceKey(var_handle_op);
      op->emitRemark(llvm::formatv(
          "device: \"{0}\", container: \"{1}\", shared_name: \"{2}\", "
          "is_potentially_written: {3}",
          resource_key.device, resource_key.container, resource_key.shared_name,

    int num_elements_threshold = quant_options_.min_num_elements_for_weights();
    int num_elements = cast<ShapedType>(op.getType()).getNumElements();
    if (num_elements < num_elements_threshold) {
      op->emitRemark("Quantization is skipped because the op has ")
          << num_elements << " elements which is fewer than the threshold("
          << num_elements_threshold << " elements).";
      return failure();
    }

      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
            << " elements which is fewer than the threshold("