A. Unique TensorFlower <******@****.***> 1591817060 -0700

	targ := r.Sym()

	var targType sym.SymKind
	if targ != 0 {
		targType = ldr.SymType(targ)
	}

	switch r.Type() {
	case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_CALL),
		objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_CALL_PLT):

		if targType == sym.SDYNIMPORT {
			addpltsym(target, ldr, syms, targ)
			su := ldr.MakeSymbolUpdater(s)

Clustered nodes: 2725
Unclustered nodes: 606
Number of clusters: 2

unclustered size 606
 AssignAddVariableOp 1
 Const 108
 DivNoNan 1
 Identity 2
 Merge 53
 PlaceholderWithDefault 1
 ReadVariableOp 2
 Switch 1
 _Arg 435
 _Retval 2
cluster 0 size 1910
 Add 16
 AddN 71
 ArgMax 1
 AssignAddVariableOp 1
 BiasAdd 1
 BiasAddGrad 1
 Cast 115
 Const 407
 Conv2D 53
 Conv2DBackpropFilter 53
 Conv2DBackpropInput 52

  // There are 2 nodes in the graph, one for arg and another for retval.
  ASSERT_THAT(exported_model->graph_def().node(), SizeIs(2));

  // Match the `_Arg` node that corresponds to the argument of @main.
  const auto arg_node_itr =
      llvm::find_if(exported_model->graph_def().node(),
                    [](const NodeDef& node) { return node.op() == "_Arg"; });

import (
	"syscall"
	"unsafe"
)

//go:cgo_import_dynamic libc_ioctl ioctl "libc.a/shr_64.o"
//go:linkname libc_ioctl libc_ioctl
var libc_ioctl uintptr

// Implemented in syscall/syscall_aix.go.
func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)

func Ioctl(fd int, cmd int, args unsafe.Pointer) (err error) {

namespace {

StatusOr<std::unique_ptr<Graph>> SampleGraphAddXY() {
  std::unique_ptr<Graph> graph(new Graph(OpRegistry::Global()));
  Scope scope = Scope::NewRootScope().ExitOnError();
  auto a = ops::_Arg(scope.WithOpName("A"), DT_INT32, 0);
  auto b = ops::_Arg(scope.WithOpName("B"), DT_INT32, 1);
  auto c = ops::Add(scope.WithOpName("C"), a, b);
  auto d = ops::_Retval(scope.WithOpName("D"), c, 0);
  TF_RETURN_IF_ERROR(scope.ToGraph(graph.get()));

        "--listclaim",
        action='append',
        nargs='+',
        help="A list claim in format key1 value2 value3... Only string values are supported. Multiple list claims can be specified, e.g., -listclaim key1 val2 val3 -listclaim key2 val3 val4.")
    parser.add_argument(
        "-nestedclaim",
        "--nestedclaim",
        action='append',
        nargs='+',

node {
  name: "arg"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "index"
    value {
      i: 0
    }
  }
}
node {
  name: "retval"
  op: "_Retval"
  input: "arg"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {

//go:linkname procIoctl libc_ioctl

var procIoctl uintptr

func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (uintptr, uintptr, syscall.Errno)

func ioctl(s, ioc uintptr, arg unsafe.Pointer) error {
	_, _, errno := sysvicall6(uintptr(unsafe.Pointer(&procIoctl)), 3, s, ioc, uintptr(arg), 0, 0, 0)
	if errno != 0 {
		return error(errno)
	}
	return nil

     tf_executor.fetch %outputs : tensor<8x1xf32>
  }
  func.return %0 : tensor<8x1xf32>
}

// Check that we generate _handle_dtypes and _handle_shapes for the resource
// argument.

// CHECK:      op: "_Arg"

// CHECK:        key: "_handle_dtypes"
// CHECK-NEXT:   value {
// CHECK-NEXT:     list {
// CHECK-NEXT:       type: DT_FLOAT
// CHECK-NEXT:     }
// CHECK-NEXT:   }
// CHECK-NEXT: }