std::string function_name = absl::StrCat(interface_name.getValue().str(), "_",
                                           device.getValue().str(), "_",
                                           inference_type.getValue().str());
  added_func_op.setName(builder.getStringAttr(function_name));
  added_call_op.setCallee(builder.getStringAttr(function_name));
}

    auto call_op = cast<TF::PartitionedCallOp>(quantized_op);
    StringRef function_name =
        call_op.getFAttr().cast<FlatSymbolRefAttr>().getValue();
    // The below can be generalized as there are more read-only ops added such
    // as slice.
    const bool is_gather = function_name.contains("gather");
    return quantization_trait != kFullQuantization || is_gather;
  }

    ret {
      key: "foo_grad2"
      value: "mul_0:z:0"
    }
    attr {
      key: "_disable_call_shape_inference"
      value {
        b: true
      }
    }
  }
  gradient {
    function_name: "foo"
    gradient_func: "foo_grad"
  }
}
versions {
  producer: 29
  min_consumer: 12

    if (!ShouldIncludeInMainFunction(func_op)) continue;
    if (auto tf_attrs =
            func_op->getAttrOfType<DictionaryAttr>(kEntryFunctionAttr)) {
      StringRef function_name = func_op.getSymName();

      if (auto inputs_attr = tf_attrs.get("inputs")) {
        const std::string inputs_attr_str =
            mlir::cast<StringAttr>(inputs_attr).getValue().str();

    value:           CamelCase
  - key:             readability-identifier-naming.EnumCase
    value:           CamelCase
  - key:             readability-identifier-naming.FunctionCase
    value:           camelBack
  - key:             readability-identifier-naming.MemberCase
    value:           camelBack
  - key:             readability-identifier-naming.ParameterCase
    value:           camelBack

  return tfr_lib_env_val != nullptr ? MlirOptimizationPassState::Enabled
                                    : MlirOptimizationPassState::Disabled;
}

Status GraphDecomposePass::Run(
    const std::string& function_name, const ConfigProto& config_proto,
    mlir::ModuleOp module, const Graph& graph,
    const FunctionLibraryDefinition& function_library) {
  if (GetPassState(/*device_set=*/nullptr, config_proto, graph,

  }

  const std::string& function_name = functiondef.signature().name();
  EagerContext* cpp_context = ContextFromInterface(unwrap(tfe_context));
  FunctionLibraryDefinition& flib_def = *cpp_context->FuncLibDef();
  const tensorflow::FunctionDef* fdef = flib_def.Find(function_name);
  if (fdef == nullptr) {
    s = tensorflow::errors::NotFound("Cannot find function ", function_name);
    tsl::Set_TF_Status_from_Status(status, s);

}

FunctionDefLibrary CreateFunctionDefLibWithConstFunction(const string& name) {
  FunctionDefLibrary fdef_lib;
  FunctionDef func = FunctionDefHelper::Create(
      /*function_name=*/name, /*in_def=*/{}, /*out_def=*/{"out: float"},
      /*attr_def*/
      {}, /*node_def=*/{FunctionDefHelper::Const("one", 1.0f)},
      /*ret_def=*/{{"out", "out:output:0"}});

namespace {
using Status = ::tensorflow::Status;
using ConfigProto = ::tensorflow::ConfigProto;
using Graph = ::tensorflow::Graph;
}  // namespace

Status MlirGraphOptimizationPass::Run(
    const std::string& function_name, const ConfigProto& config_proto,
    ModuleOp module, const Graph& graph,
    const tensorflow::FunctionLibraryDefinition& function_library) {
  if (GetPassState(/*device_set=*/nullptr, config_proto, graph,

  //    function call into the outputs of the XlaLaunch operator.
  static Status BuildXlaLaunchOps(Graph* graph);

  struct XlaFunctionInfo {
    int variable_start_index = -1;
    std::string function_name;
  };

  // We need to introduce this version to adapt to the output of gpu inference
  // converter. The single argument overload version calls this function.
  //