// In the current compiler implementation, for zerorange to be
// invoked, we need to have an ambiguously live variable that needs
// zeroing. One way to trigger this is to have a function with an
// open-coded defer, where the opendefer function has an argument that
// contains a pointer (this is what's used below).
//
// At the moment this test doesn't do any specific checking for
// code sequence, or verification that things were properly set to zero,

		// data symbols more carefully.
		switch {
		case strings.HasPrefix(s.Name, "go:string."),
			strings.HasPrefix(name, "type:.namedata."),
			strings.HasPrefix(name, "type:.importpath."),
			strings.HasSuffix(name, ".opendefer"),
			strings.HasSuffix(name, ".arginfo0"),
			strings.HasSuffix(name, ".arginfo1"),
			strings.HasSuffix(name, ".argliveinfo"):
			// These are just bytes, or varints.
			align = 1

			strings.HasPrefix(name, "gclocals."),
			strings.HasPrefix(name, "gclocals·"),
			ldr.SymType(s) == sym.SGOFUNC && s != symgofunc, // inltree, see pcln.go
			strings.HasSuffix(name, ".opendefer"),
			strings.HasSuffix(name, ".arginfo0"),
			strings.HasSuffix(name, ".arginfo1"),
			strings.HasSuffix(name, ".argliveinfo"),
			strings.HasSuffix(name, ".wrapinfo"),
			strings.HasSuffix(name, ".args_stackmap"),

		opendefer.closure = closure
	}
	index := len(s.openDefers)
	s.openDefers = append(s.openDefers, opendefer)

	// Update deferBits only after evaluation and storage to stack of
	// the function is successful.
	bitvalue := s.constInt8(types.Types[types.TUINT8], 1<<uint(index))

  return absl::Substitute("$0 $1($2)", "Status", op_.FunctionName(),
                          absl::StrJoin(arguments, ", "));
}

OpRenderer::OpRenderer(RendererContext context, OpView op)
    : Renderer(context), op_(op), comment_(context, op) {}

void OpRenderer::Render() {
  comment_.Render();
  if (context_.mode == RendererContext::kHeader) {
    Statement(Signature());
  } else {
    BlockOpen(Signature());

#include "tensorflow/c/experimental/ops/gen/cpp/views/op_view.h"
#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {
namespace cpp {

class OpRenderer : public Renderer {
 public:
  explicit OpRenderer(RendererContext context, OpView op);
  void Render();

 private:
  OpView op_;
  OpCommentRenderer comment_;

  string Signature() const;
};

}  // namespace cpp

    guard_.Open();
  } else {
    includes_.SelfHeader();
  }

  includes_.Headers();
  name_space_.Open();
  BlankLine();

  for (const OpView &op : ops_) {
    OpRenderer(context_, op).Render();
  }

  name_space_.Close();
  if (context_.mode == RendererContext::kHeader) {
    guard_.Close();
  }
}

}  // namespace cpp
}  // namespace generator