// run -gcflags=-d=checkptr

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that reflect.Value.UnsafeAddr/Pointer is handled
// correctly by -d=checkptr

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	n := 10
	m := make(map[string]string)

// run -gcflags=-d=checkptr

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "unsafe"

func main() {
	var x [2]uint64
	a := unsafe.Pointer(&x[1])

	b := a
	b = unsafe.Pointer(uintptr(b) + 2)
	b = unsafe.Pointer(uintptr(b) - 1)
	b = unsafe.Pointer(uintptr(b) &^ 1)

	if a != b {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build darwin

package issue24161e1

/*
#cgo CFLAGS: -x objective-c
#cgo LDFLAGS: -framework CoreFoundation -framework Security
#include <TargetConditionals.h>
#include <CoreFoundation/CoreFoundation.h>
#include <Security/Security.h>

// asmcheck -gcflags=-spectre=index

//go:build amd64

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package codegen

func IndexArray(x *[10]int, i int) int {
	// amd64:`CMOVQCC`
	return x[i]
}

func IndexString(x string, i int) byte {
	// amd64:`CMOVQ(LS|CC)`
	return x[i]
}

env GOFLAGS='-m -v'
go version
stdout '^go version'
env GOFLAGS=

env GO111MODULE=on

# Check that very basic version lookup succeeds.
go build empty.go
go version empty$GOEXE
[cgo] go build -ldflags=-linkmode=external empty.go
[cgo] go version empty$GOEXE

# Skip the remaining builds if we are running in short mode.
[short] skip

# Check that 'go version' and 'go version -m' work on a binary built in module mode.

//sys	Dup(fd int) (nfd int, err error)
//sys	Dup2(from int, to int) (err error)
//sys	Exit(code int)
//sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
//sys	Fchdir(fd int) (err error)
//sys	Fchflags(fd int, flags int) (err error)
//sys	Fchmod(fd int, mode uint32) (err error)
//sys	Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
//sys	Fchown(fd int, uid int, gid int) (err error)

//sys	Dup3(from int, to int, flags int) (err error)
//sys	Exit(code int)
//sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
//sys	Fchdir(fd int) (err error)
//sys	Fchflags(fd int, flags int) (err error)
//sys	Fchmod(fd int, mode uint32) (err error)
//sys	Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
//sys	Fchown(fd int, uid int, gid int) (err error)

// run for an arbitrarily long time without triggering the libc interceptors.
// See https://golang.org/issue/18717.

import (
	"os"
	"os/signal"
	"syscall"
)

/*
#cgo CFLAGS: -g -fsanitize=thread
#cgo LDFLAGS: -g -fsanitize=thread
*/
import "C"

func main() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, syscall.SIGUSR1)
	defer signal.Stop(c)
	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)

/*
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <arpa/nameser.h>
#include <resolv.h>

#cgo !android,!openbsd LDFLAGS: -lresolv
*/
import "C"

type _C_struct___res_state = struct{}

func _C_res_ninit(state *_C_struct___res_state) error {
	return nil
}

func _C_res_nclose(state *_C_struct___res_state) {
	return
}

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build cgo && !netgo

package net

/*
#cgo LDFLAGS: -lsocket -lnsl -lsendfile
#include <netdb.h>
*/
import "C"