// license that can be found in the LICENSE file.

package main

// Check that writes to Go allocated memory, with Go synchronization,
// do not look like a race.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

void f(char *p) {
	*p = 1;
}
*/
import "C"

import (
	"runtime"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex

// TSAN library was not keeping track of whether signals should be
// delivered on the alternate signal stack, and the Go signal handler
// was not preserving callee-saved registers from C callers.

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

#include <stdlib.h>
#include <sys/time.h>

void spin() {
	size_t n;
	struct timeval tvstart, tvnow;
	int diff;
	void *prev = NULL, *cur;

// license that can be found in the LICENSE file.

package main

// Check that calls to C.malloc/C.free do not collide with the calls
// made by the os/user package.

// #cgo CFLAGS: -fsanitize=thread
// #cgo LDFLAGS: -fsanitize=thread
// #include <stdlib.h>
import "C"

import (
	"fmt"
	"os"
	"os/user"
	"runtime"
	"sync"
)

func main() {
	u, err := user.Current()
	if err != nil {

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

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static void raise_usr2(int signo) {
	raise(SIGUSR2);
}

// This program failed when run under the C/C++ ThreadSanitizer.  The TSAN
// sigaction function interceptor returned SIG_DFL instead of the Go runtime's
// handler in registerSegvForwarder.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct sigaction prev_sa;

void forwardSignal(int signo, siginfo_t *info, void *context) {

// The Go runtime had re-registered the C handler with the wrong flags due to a
// typo, resulting in null pointers being passed for the info and context
// parameters to the handler.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ucontext.h>

void check_params(int signo, siginfo_t *info, void *context) {

package main

// This program failed when run under the C/C++ ThreadSanitizer.
// There was no TSAN synchronization for the call to the cgo
// traceback routine.

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

#include <pthread.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>

struct tracebackArg {
	uintptr_t  Context;

// license that can be found in the LICENSE file.

//go:build asan && linux && (arm64 || amd64 || loong64 || riscv64 || ppc64le)

package asan

/*
#cgo CFLAGS: -fsanitize=address
#cgo LDFLAGS: -fsanitize=address

#include <stdbool.h>
#include <stdint.h>
#include <sanitizer/asan_interface.h>

void __asan_read_go(void *addr, uintptr_t sz, void *sp, void *pc) {

	ss_sp     *byte
	ss_flags  int32
	pad_cgo_0 [4]byte
	ss_size   uintptr
}

type sigcontext struct {
	sc_pc         uint64
	sc_regs       [32]uint64
	sc_flags      uint32
	sc_extcontext [0]uint64
}

type ucontext struct {
	uc_flags     uint64
	uc_link      *ucontext
	uc_stack     stackt
	uc_sigmask   usigset
	uc_x_unused  [0]uint8
	uc_pad_cgo_0 [8]byte
	uc_mcontext  sigcontext

	mc_fpformat      uint32
	mc_ownedfp       uint32
	mc_flags         uint32
	mc_fpstate       [128]uint32
	mc_fsbase        uint32
	mc_gsbase        uint32
	mc_xfpustate     uint32
	mc_xfpustate_len uint32
	mc_spare2        [4]uint32
}

type ucontext struct {
	uc_sigmask  sigset
	uc_mcontext mcontext
	uc_link     *ucontext
	uc_stack    stackt
	uc_flags    int32
	__spare__   [4]int32
	pad_cgo_0   [12]byte