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

package main

// Check that calls to C.malloc/C.free do not trigger TSAN false
// positive reports.

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

import (
	"runtime"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {

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

//go:build msan && ((linux && (amd64 || arm64 || loong64)) || (freebsd && amd64))

package msan

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

#include <stdint.h>
#include <sanitizer/msan_interface.h>

void __msan_read_go(void *addr, uintptr_t sz) {
	__msan_check_mem_is_initialized(addr, sz);
}

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

package main

// The stubs for the C functions read and write the same slot on the
// g0 stack when copying arguments in and out.

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

int Func1() {
	return 0;
}

void Func2(int x) {
	(void)x;
}
*/
import "C"

func main() {
	const N = 10000
	done := make(chan bool, N)

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

package cgotest

/*
#cgo CFLAGS: -pthread
#cgo LDFLAGS: -pthread
extern int RunSigThread();
extern int CheckBlocked();
*/
import "C"
import (
	"os"
	"os/signal"
	"syscall"
	"testing"
)

var blocked bool

//export IntoGoAndBack

package main

// Setting an environment variable in a cgo program changes the C
// environment. Test that this does not confuse the race detector.

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

import (
	"fmt"
	"os"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup
	var mu sync.Mutex
	f := func() {
		defer wg.Done()

// goSource is the source code for the trivial Go file we use.
// We will replace TMPDIR with the temporary directory name.
const goSource = `
package main

// #cgo LDFLAGS: TMPDIR/cbad.o TMPDIR/cbad.so
// extern int F();
import "C"

func main() {
	println(C.F())
}
`

func TestBadSymbol(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveCGO(t)

go build -x -n main.go
stderr '"-I[^"]+c flags"' # find quoted c flags
! stderr '"-I[^"]+c flags".*"-I[^"]+c flags"' # don't find too many quoted c flags per line
stderr '"-L[^"]+ld flags"' # find quoted ld flags
! stderr '"-L[^"]+c flags".*"-L[^"]+c flags"' # don't find too many quoted ld flags per line

-- main.go --
package main
// #cgo CFLAGS: -I"c flags"

#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 !aix,!dragonfly,!freebsd LDFLAGS: -lresolv
*/
import "C"

type _C_struct___res_state = C.struct___res_state

func _C_res_ninit(state *_C_struct___res_state) error {
	_, err := C.res_ninit(state)
	return err
}

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

//go:build darwin

package issue24161e0

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

# Test case for issue 47993, in which the linker crashes
# on a bad input instead of issuing an error and exiting.

# This test requires external linking, so use cgo as a proxy 
[!cgo] skip

! go build -ldflags='-linkmode=external' .
! stderr 'panic'
stderr '^.*undefined symbol in relocation.*'

-- go.mod --

module issue47993

go 1.16

-- main.go --

package main

type M struct {
	b bool
}