// GraphDefs, return the Graph generated in LoadSavedModel().
  TF_ImportGraphDefOptions* import_opts = TF_NewImportGraphDefOptions();
  TF_ImportGraphDefResults results;
  GraphImportGraphDefLocked(graph, bundle.meta_graph_def.graph_def(),
                            import_opts, &results, status);
  TF_DeleteImportGraphDefOptions(import_opts);
  if (!status->status.ok()) return nullptr;

  if (meta_graph_def != nullptr) {

  memcpy(ret, debug_str.c_str(), *len + 1);
  return ret;
}

char* TF_FunctionDebugString(TF_Function* func, size_t* len) {
  const auto& debug_str = DebugString(func->record->fdef());
  *len = debug_str.size();
  char* ret = static_cast<char*>(malloc(*len + 1));
  memcpy(ret, debug_str.c_str(), *len + 1);
  return ret;
}

namespace tracing {
namespace graph {
GraphFunction::GraphFunction(FunctionDef fdef)
    : AbstractFunction(kGraph),
      func_record_(new FunctionRecord(std::move(fdef), {}, true)) {}
GraphFunction::~GraphFunction() {}
Status GraphFunction::GetFunctionDef(const FunctionDef **fdef) {
  *fdef = &(func_record_->fdef());
  return absl::OkStatus();
}
}  // namespace graph
}  // namespace tracing

  tensorflow::mutex_lock l(g->mu);
  status->status = g->graph.AddFunctionDef(func->record->fdef(),
                                           func->record->stack_traces());
  if (TF_GetCode(status) != TF_OK) return;
  if (!grad) return;

  status->status = g->graph.AddFunctionDef(grad->record->fdef(),
                                           grad->record->stack_traces());
  if (TF_GetCode(status) != TF_OK) return;

    //     and places the 'read0_maybe_with_graph_error' op on task:2
    //   * task:0 partitions the main function with a subgraph containing
    //     'read0_maybe_with_graph_error' sent to task:2
    //   * task:2 graph pass reports an error when it sees
    //     'read0_maybe_with_graph_error' with dev2_name
    tensorflow::function_optimization_registration::
        FunctionOptimizationPassRegistration register_test_pass(

  tensorflow::core::RefCountPtr<tensorflow::FunctionRecord> record =
      tensorflow::unwrap(ctx)->FindRecord(name);

  if (record == nullptr) {
    status->status = tensorflow::errors::NotFound(
        "Unable to find Function with name: ", name);
    return nullptr;
  }

  TF_Function* result = new TF_Function();
  record->Ref();
  result->record = record.get();
  return result;
}

  auto function_record = tensorflow::unwrap(ctx)->FindRecord(function_name);
  if (function_record == nullptr) {
    status->status = tensorflow::errors::NotFound(
        "Unable to find function with name: ", function_name);
    return;
  }

  tensorflow::GraphDebugInfo debug_info =
      tensorflow::StackTracesMapToGraphDebugInfo(
          function_record->stack_traces());

                                   graph_outputs.size(), graph_outputs.data(),
                                   nullptr, nullptr, name_.data(), s);
    *f = new GraphFunction(std::move(func->record->fdef()));
    TF_DeleteFunction(func);
    TF_RETURN_IF_ERROR(StatusFromTF_Status(s));
    TF_DeleteStatus(s);
    return absl::OkStatus();
  }

  Status RegisterFunction(AbstractFunction* func) override {

  TF_Input feed_port;
  EXPECT_EQ(1, TF_OperationOutputConsumers(TF_Output{feed, 0}, &feed_port, 1));
  EXPECT_EQ(add, feed_port.oper);
  EXPECT_EQ(0, feed_port.index);

  // The scalar const oper also has a consumer.
  ASSERT_EQ(1, TF_OperationOutputNumConsumers(TF_Output{three, 0}));
  TF_Input three_port;
  EXPECT_EQ(1,