func.return %0 : tensor<2xi32>
}

// -----

// CHECK-LABEL: listFromTensor
func.func @listFromTensor(%tensor: tensor<3xi32>, %shape : tensor<?xi32>) -> tensor<!tf_type.variant<tensor<i32>>> {
  %0 = "tf.TensorListFromTensor"(%tensor, %shape) : (tensor<3xi32>, tensor<?xi32>) -> tensor<!tf_type.variant<tensor<i32>>>
  func.return %0 : tensor<!tf_type.variant<tensor<i32>>>

//go:noescape
func Load(ptr *uint32) uint32

//go:noescape
func Load8(ptr *uint8) uint8

//go:noescape
func Load64(ptr *uint64) uint64

// NO go:noescape annotation; *ptr escapes if result escapes (#31525)
func Loadp(ptr unsafe.Pointer) unsafe.Pointer

//go:noescape
func LoadAcq(ptr *uint32) uint32

//go:noescape
func LoadAcq64(ptr *uint64) uint64

//go:noescape
func LoadAcquintptr(ptr *uintptr) uintptr

//go:noescape

// CHECK: func{{.*}}dialect = "x"
// CHECK-NEXT: x.b
// CHECK: func{{.*}}dialect = "y"
// CHECK-NEXT: y.b
// CHECK: func{{.*}}dialect = "z"
// CHECK-NEXT: z.b
// CHECK: func{{.*}}dialect = "x"
// CHECK-NEXT: x.c
// CHECK: func{{.*}}dialect = "y"
// CHECK-NEXT: y.c
// CHECK: func{{.*}}dialect = "z"
// CHECK-NEXT: z.c

// -----

func.func @statements(%arg0: f32, %arg1: f32) -> (f32, f32) {

func (t *testInitData) KubeConfigDir() string                                { return "" }
func (t *testInitData) KubeConfigPath() string                               { return "" }
func (t *testInitData) ManifestDir() string                                  { return "" }
func (t *testInitData) KubeletDir() string                                   { return "" }
func (t *testInitData) ExternalCA() bool                                     { return false }

func (c *sigctxt) r5() uint64  { return (uint64)(c.regs().sc_x[5]) }
func (c *sigctxt) r6() uint64  { return (uint64)(c.regs().sc_x[6]) }
func (c *sigctxt) r7() uint64  { return (uint64)(c.regs().sc_x[7]) }
func (c *sigctxt) r8() uint64  { return (uint64)(c.regs().sc_x[8]) }
func (c *sigctxt) r9() uint64  { return (uint64)(c.regs().sc_x[9]) }
func (c *sigctxt) r10() uint64 { return (uint64)(c.regs().sc_x[10]) }

  func.return
}

// CHECK-LABEL: func @no_embedding_ops
func.func @no_embedding_ops(%arg0: tensor<2x2xf32>) -> (tensor<2x2xf32>) {
  // CHECK: tf.Add
  %0 = "tf.Add"(%arg0, %arg0) : (tensor<2x2xf32>, tensor<2x2xf32>) -> tensor<2x2xf32>
  func.return %0 : tensor<2x2xf32>
}

// CHECK-LABEL: func @nested_embedding_op

func (c *sigctxt) r5() uint64  { return c.regs().mc_gpregs.gp_x[5] }
func (c *sigctxt) r6() uint64  { return c.regs().mc_gpregs.gp_x[6] }
func (c *sigctxt) r7() uint64  { return c.regs().mc_gpregs.gp_x[7] }
func (c *sigctxt) r8() uint64  { return c.regs().mc_gpregs.gp_x[8] }
func (c *sigctxt) r9() uint64  { return c.regs().mc_gpregs.gp_x[9] }
func (c *sigctxt) r10() uint64 { return c.regs().mc_gpregs.gp_x[10] }

func (c *sigctxt) t1() uint64  { return uint64(c.regs().sc_t[1]) }
func (c *sigctxt) t2() uint64  { return uint64(c.regs().sc_t[2]) }
func (c *sigctxt) s0() uint64  { return uint64(c.regs().sc_s[0]) }
func (c *sigctxt) s1() uint64  { return uint64(c.regs().sc_s[1]) }
func (c *sigctxt) a0() uint64  { return uint64(c.regs().sc_a[0]) }
func (c *sigctxt) a1() uint64  { return uint64(c.regs().sc_a[1]) }
func (c *sigctxt) a2() uint64  { return uint64(c.regs().sc_a[2]) }

//go:noescape
func Or8(ptr *uint8, val uint8)

// NOTE: Do not add atomicxor8 (XOR is not idempotent).

//go:noescape
func And(ptr *uint32, val uint32)

//go:noescape
func Or(ptr *uint32, val uint32)

//go:noescape
func And32(ptr *uint32, val uint32) uint32

//go:noescape
func Or32(ptr *uint32, val uint32) uint32

//go:noescape
func And64(ptr *uint64, val uint64) uint64

//go:noescape

}

func (t *Target) IsMIPS64() bool {
	return t.Arch.Family == sys.MIPS64
}

func (t *Target) IsLOONG64() bool {
	return t.Arch.Family == sys.Loong64
}

func (t *Target) IsPPC64() bool {
	return t.Arch.Family == sys.PPC64
}

func (t *Target) IsRISCV64() bool {
	return t.Arch.Family == sys.RISCV64
}

func (t *Target) IsS390X() bool {
	return t.Arch.Family == sys.S390X
}