for (int i = 0; i < ninputs; ++i) {
    input_names[i] = c_input_names[i];
  }
  for (int i = 0; i < noutputs; ++i) {
    output_names[i] = c_output_names[i];
  }
  for (int i = 0; i < ntargets; ++i) {
    target_oper_names[i] = c_target_oper_names[i];
  }
  string new_handle;
  status->status = s->session->PRunSetup(input_names, output_names,

        const std::string inputs_attr_str =
            mlir::cast<StringAttr>(inputs_attr).getValue().str();
        std::vector<std::string> fn_input_names =
            absl::StrSplit(inputs_attr_str, ',', absl::SkipEmpty());

        for (StringRef input_name : fn_input_names) {
          if (input_name_set.contains(input_name)) {
            // Found a duplicated name, all input names will be prefixed by

      }
    }

    for (auto func_name : func_names) {
      TFRTSavedModelSignatureInfo sig_info;
      sig_info.func_name = func_name;
      sig_info.input_names = input_names;
      sig_info.input_specs = input_specs;
      sig_info.input_devices = input_devices;
      sig_info.output_names = output_names;
      sig_info.output_specs = output_specs;

  // Retrieve input names from model flags.
  std::vector<std::string> input_names;
  for (const auto& input : model_flags.input_arrays()) {
    input_names.push_back(input.name());
  }

  const auto& inputs = absl::StrJoin(input_names, ",");
  mlir::OpBuilder builder(*module);
  llvm::SmallVector<mlir::NamedAttribute> attrs;
  attrs.push_back(

}  // namespace

FailureOr<SmallVector<AssetFileDef>> ConvertAssetArgs(ModuleOp module_op) {
  func::FuncOp main_func_op = FindMainFuncOp(module_op);
  if (!main_func_op) return failure();

  SmallVector<StringRef> input_names = GetEntryFunctionInputs(main_func_op);
  SymbolTable symbol_table(module_op);
  SmallVector<AssetFileDef> asset_file_defs;

  for (BlockArgument argument : main_func_op.getArguments()) {

// be used to retrieve these information in a tf_saved_model module.
struct TFRTSavedModelSignatureInfo {
  llvm::StringRef func_name;

  // The following are metadata for inputs.
  llvm::ArrayRef<llvm::StringRef> input_names;
  llvm::ArrayRef<
      std::pair<tensorflow::DataType, tensorflow::PartialTensorShape>>
      input_specs;
  llvm::ArrayRef<llvm::StringRef> input_devices;

  // The following are metadata for outputs.

          exporter.op_to_name_.GetUniqueName(tensor_id_node));
    }
  }

  if (!input_names.empty()) {
    TF_RET_CHECK(input_names.size() == block.getNumArguments());
    for (const auto& it : llvm::enumerate(function.getArguments())) {
      // TODO(lyandy): Update when changing feed/fetch import.
      std::string name(input_names[it.index()]);
      assert(!name.empty() && "expected non-empty name");

          exporter.op_to_name_.GetUniqueName(tensor_id_node));
    }
  }

  if (!input_names.empty()) {
    TF_RET_CHECK(input_names.size() == block.getNumArguments());
    for (const auto& it : llvm::enumerate(function.getArguments())) {
      // TODO(lyandy): Update when changing feed/fetch import.
      std::string name(input_names[it.index()]);
      assert(!name.empty() && "expected non-empty name");

  auto input_attr = tf_attrs.get("inputs");
  if (!input_attr) {
    return errors::InvalidArgument("no inputs attribute found");
  }
  auto input_names = mlir::cast<mlir::StringAttr>(input_attr).getValue();
  input_names.split(function_input_names, ",", /*MaxSplit=*/-1,
                    /*KeepEmpty=*/false);
  const int function_input_names_size = function_input_names.size();

std::string ImportGraphDef(const std::string &proto,
                           const std::string &pass_pipeline,
                           bool show_debug_info, absl::string_view(input_names),
                           absl::string_view(input_data_types),
                           absl::string_view(input_data_shapes),
                           absl::string_view(output_names), TF_Status *status);