std::vector<int64_t> tensor_stack;
  tensor_stack.reserve(target.size());
  for (auto t : target) {
    tensor_stack.push_back(t);
  }
  BackpropInitialState<BackwardFunction, TapeTensor> result;
  while (!tensor_stack.empty()) {
    int64_t tensor_id = tensor_stack.back();
    tensor_stack.pop_back();
    auto op_id_it = tensor_tape.find(tensor_id);

  // Same as `AddFunctionDef`, but additionally saves the `stack_traces` under
  // the key of the function definition name (to be retrieved during function
  // instantiation).
  virtual Status AddFunctionDefWithStackTraces(
      const FunctionDef& fdef, const StackTracesMap& stack_traces) = 0;

  // Find and return a added function by its name.

  tensorflow::StackTracesMap stack_traces;
  for (const Node* n : fn_body->graph.nodes()) {
    stack_traces[n->name()] = n->GetStackTrace();
  }

  TF_Function* tf_function = new TF_Function();
  tf_function->record = new tensorflow::FunctionRecord(
      std::move(fdef), std::move(stack_traces), false);

  return tf_function;
}

                                                        TF_Status* status);

// Some TF ops need a step container to be set to limit the lifetime of some
// resources (mostly TensorArray and Stack, used in while loop gradients in
// graph mode). Calling this on a context tells it to start a step.
TF_CAPI_EXPORT extern void TFE_ContextStartStep(TFE_Context* ctx);

                                                     TF_Buffer* buf,
                                                     TF_Status* status);

// Get GraphDebugInfo containing stack traces mapping to node names
TF_CAPI_EXPORT extern void TFE_ContextGetGraphDebugInfo(
    TFE_Context* ctx, const char* function_name, TF_Buffer* buf,
    TF_Status* status);

// Extracts a TF_Function from the context.

        "Unable to find function with name: ", function_name);
    return;
  }

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

  string str = debug_info.SerializeAsString();
  void* data = tensorflow::port::Malloc(str.length());
  str.copy(static_cast<char*>(data), str.length(), 0);
  buf->data = data;

    return;
  }

  AnnotateEagerRuntimeConstructionContext(*fdef_or.value());
  status->status = tensorflow::unwrap(ctx)->AddFunctionDefWithStackTraces(
      *fdef_or.value(), function->record->stack_traces());
}

TF_Function* TFE_ContextGetFunction(TFE_Context* ctx, const char* name,
                                    TF_Status* status) {
  tensorflow::core::RefCountPtr<tensorflow::FunctionRecord> record =

        "//tensorflow/c:tensor_interface",
        "//tensorflow/core:framework",
        "//tensorflow/core:lib",
        "//tensorflow/core:protos_all_cc",
        "//tensorflow/core/util:managed_stack_trace",
        "@com_google_absl//absl/types:optional",
        "@com_google_absl//absl/types:span",
    ],
)

cc_library(
    name = "abstract_context",
    hdrs = ["abstract_context.h"],

tracking requests and bugs, please see
[TensorFlow Forum](https://discuss.tensorflow.org/) for general questions and
discussion, and please direct specific questions to
[Stack Overflow](https://stackoverflow.com/questions/tagged/tensorflow).**

The TensorFlow project strives to abide by generally accepted best practices in
open-source software development.

## Patching guidelines

  CancellationManager* cancellation_manager_ TF_GUARDED_BY(execution_mutex_);
  //   Outputs:
  std::vector<TensorHandlePtr> op_outputs_ TF_GUARDED_BY(execution_mutex_);
  // TF_Status is an incomplete type and so can't be stack allocated. To avoid
  // unnecessary allocations each Execute call, we keep one heap-allocated
  // version for the thread.
  StatusPtr status_ TF_GUARDED_BY(execution_mutex_);

  const std::string device_;