//go:build !purego

package sha512

import "internal/cpu"

//go:noescape
func blockAVX2(dig *digest, p []byte)

//go:noescape
func blockAMD64(dig *digest, p []byte)

var useAVX2 = cpu.X86.HasAVX2 && cpu.X86.HasBMI1 && cpu.X86.HasBMI2

func block(dig *digest, p []byte) {
	if useAVX2 {
		blockAVX2(dig, p)
	} else {
		blockAMD64(dig, p)
	}

}

func (c *client) API() api.DevicePluginClient {
	return c.client
}

func (c *client) SocketPath() string {
	return c.socket
}

// dial establishes the gRPC communication with the registered device plugin. https://godoc.org/google.golang.org/grpc#Dial
func dial(unixSocketPath string) (api.DevicePluginClient, *grpc.ClientConn, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

func New(priority Priority, tag string) (*Writer, error) {
	return Dial("", "", priority, tag)
}

// Dial establishes a connection to a log daemon by connecting to
// address raddr on the specified network. Each write to the returned
// writer sends a log message with the facility and severity
// (from priority) and tag. If tag is empty, the [os.Args][0] is used.
// If network is empty, Dial will connect to the local syslog server.

		}
	}
	fd, err := internetSocket(ctx, sd.network, laddr, raddr, syscall.SOCK_STREAM, proto, "dial", ctrlCtxFn)

	// TCP has a rarely used mechanism called a 'simultaneous connection' in
	// which Dial("tcp", addr1, addr2) run on the machine at addr1 can
	// connect to a simultaneous Dial("tcp", addr2, addr1) run on the machine
	// at addr2, without either machine executing Listen. If laddr == nil,

// function call.

func main() {
	var listen, _ = Listen("tcp", "127.0.0.1:0")

	go func() {
		for {
			var conn, _ = listen.Accept()
			_ = conn
		}
	}()

	var conn, _ = Dial("tcp", "", listen.Addr().Error())
	_ = conn
}

// Simulated net interface to exercise bug
// without involving a real network.
type T chan int

var global T

func Listen(x, y string) (T, string) {

	timeout := 500 * time.Millisecond
	d := NewDialer(Config{
		ProxyAddress: "127.0.0.10:1", // Random address that should fail to dial
		Headers: map[string][]string{
			"some-addition-metadata": {"test-value"},
		},
		TLS:     nil, // No TLS for simplification
		Timeout: &timeout,
	})

	_, err := d.Dial("tcp", "fake")
	if err == nil {
		t.Fatal("expected error, got none.")
	}
}

func TestDialer(t *testing.T) {

func.func @g() {
  func.return
}

// -----
// Transitive callees.
// CHECK-LABEL: func @f
// 2 copies of @g
// CHECK-DAG: func @g{{.*}}
// CHECK-DAG: func private @g{{.*}}
// 4 copies of @h
// CHECK-DAG: func @h{{.*}}
// CHECK-DAG: func private @h{{.*}}
// CHECK-DAG: func private @h{{.*}}
// CHECK-DAG: func private @h{{.*}}
func.func @f() {
  func.call @g() : () -> ()
  func.call @g() : () -> ()
  func.return
}

      type: DT_BOOL
    }
  }
}

# CHECK-DAG: tf.IteratorGetNext{{.+}}-> (tensor<1x8xbf16>, tensor<2x?x16xf32>, tensor<*xf64>)
# CHECK-DAG: tf.IteratorGetNextSync{{.+}}-> (tensor<*xi16>, tensor<3x24xi32>, tensor<?x4x32xi64>)
# CHECK-DAG: tf.MultiDeviceIteratorGetNextFromShard{{.+}}-> (tensor<5x40xf16>, tensor<*xcomplex<f32>>, tensor<6x48x?xcomplex<f64>>)

// Code generated by go run gen.go -output md5block.go; DO NOT EDIT.

package md5

import (
	"internal/byteorder"
	"math/bits"
)

func blockGeneric(dig *digest, p []byte) {
	// load state
	a, b, c, d := dig.s[0], dig.s[1], dig.s[2], dig.s[3]

	for i := 0; i <= len(p)-BlockSize; i += BlockSize {
		// eliminate bounds checks on p
		q := p[i:]
		q = q[:BlockSize:BlockSize]

		// save current state

// CHECK-SAME: %[[ARG1:.*]]: tensor<2x3
// CHECK-DAG: %[[CST:.*]] = "tf.Const"() <{value = dense<0.00117647066> : tensor<f32>}> : () -> tensor<f32>
// CHECK-DAG: %[[CST_0:.*]] = "tf.Const"() <{value = dense<-43> : tensor<i32>}> : () -> tensor<i32>
// CHECK-DAG: %[[CST_1:.*]] = "tf.Const"() <{value = dense<0.0117647061> : tensor<f32>}> : () -> tensor<f32>