func.return %outputs_0 : tensor<2x2xf32>
}

// CHECK-LABEL: func @fold_identity_test_device_not_defined
func.func @fold_identity_test_device_not_defined(%arg0: tensor<2x2xf32>, %arg1: tensor<2x2xf32>) -> tensor<2x2xf32> {
  // CHECK: tf.MatMul
  %outputs = "tf.MatMul"(%arg0, %arg1) {device = "", transpose_a = false, transpose_b = false} : (tensor<2x2xf32>, tensor<2x2xf32>) -> tensor<2x2xf32>

func badlinkname_rtype_AssignableTo(*rtype, Type) bool

//go:linkname badlinkname_rtype_Bits reflect.(*rtype).Bits
func badlinkname_rtype_Bits(*rtype) int

//go:linkname badlinkname_rtype_ChanDir reflect.(*rtype).ChanDir
func badlinkname_rtype_ChanDir(*rtype) ChanDir

//go:linkname badlinkname_rtype_Comparable reflect.(*rtype).Comparable
func badlinkname_rtype_Comparable(*rtype) bool

	go func() {
		a[1] = 1
		ch <- true
	}()
	a[1] = 2
	<-ch
}

func TestNoRaceArrayWW(t *testing.T) {
	var a [5]int
	ch := make(chan bool, 1)
	go func() {
		a[0] = 1
		ch <- true
	}()
	a[1] = 2
	<-ch
}

func TestRaceArrayWW(t *testing.T) {
	var a [5]int
	ch := make(chan bool, 1)
	go func() {
		a[1] = 1
		ch <- true
	}()
	a[1] = 2
	<-ch
}

type foo8 string
type foo9 string

func (f foo1) F() { return }
func (f foo2) F() { return }
func (f foo3) F() { return }
func (f foo4) F() { return }
func (f foo5) F() { return }
func (f foo6) F() { return }
func (f foo7) F() { return }
func (f foo8) F() { return }
func (f foo9) F() { return }

func Test1(s string) I  { return foo1(s) }
func Test2(s string) I  { return foo2(s) }
func Test3(s string) I  { return foo3(s) }

// CHECK-SAME:  ([[ARG0:%.+]]: tensor<i32>)
func.func @testDoubleReciprocal(%arg0: tensor<i32>) -> tensor<i32> {
  %0 = "tf.Reciprocal"(%arg0) : (tensor<i32>) -> tensor<i32>
  %1 = "tf.Reciprocal"(%0) : (tensor<i32>) -> tensor<i32>
  // CHECK: return [[ARG0]]
  func.return %1: tensor<i32>
}

// CHECK-LABEL: func @testTripleReciprocal
// CHECK-SAME:  ([[ARG0:%.+]]: tensor<i32>)

func (c *sigctxt) rdi() uint64 { return uint64(c.regs().gregs[_REG_RDI]) }
func (c *sigctxt) rsi() uint64 { return uint64(c.regs().gregs[_REG_RSI]) }
func (c *sigctxt) rbp() uint64 { return uint64(c.regs().gregs[_REG_RBP]) }
func (c *sigctxt) rsp() uint64 { return uint64(c.regs().gregs[_REG_RSP]) }
func (c *sigctxt) r8() uint64  { return uint64(c.regs().gregs[_REG_R8]) }
func (c *sigctxt) r9() uint64  { return uint64(c.regs().gregs[_REG_R9]) }

package a

import "unsafe"

func Append() {
	_ = append(appendArgs())
}

func Delete() {
	delete(deleteArgs())
}

func Print() {
	print(ints())
}

func Println() {
	println(ints())
}

func Complex() {
	_ = complex(float64s())
}

func Copy() {
	copy(slices())
}

func UnsafeAdd() {
	_ = unsafe.Add(unsafeAdd())
}

func.func private @f(%arg0: tensor<f32>, %arg1: tensor<f32>) {
  return
}

// CHECK-LABEL: removes_all_args
func.func @removes_all_args(%arg0: tensor<f32>, %arg1: tensor<f32>) {
  // CHECK: call{{.*}}() :
  func.call @f(%arg0, %arg1) : (tensor<f32>, tensor<f32>) -> ()
  return
}

// -----

// CHECK-LABEL: handles_mlprogram
// CHECK-SAME: () {

  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>>>

}

// any re-assignment prevents closure inlining
func m() int {
	foo := func() int { return 1 } // ERROR "can inline m.func1" "func literal does not escape"
	x := foo()
	foo = func() int { return 2 } // ERROR "can inline m.func2" "func literal does not escape"
	return x + foo()
}

// address taking prevents closure inlining
func n() int { // ERROR "can inline n"