TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
#ifndef GOOS_aix
#ifndef GOOS_openbsd
	MOVBZ	runtime·iscgo(SB), R31
	CMP	R31, $0
	BEQ	nocgo
#endif
#endif
	MOVD	runtime·tls_g(SB), R31
	MOVD	g, 0(R31)

nocgo:
	RET

// load_g loads the g register from pthread-provided
// thread-local memory, for use after calling externally compiled
// ppc64 code that overwrote those registers.
//

	}

	print("PC=", hex(c.sigpc()), " m=", mp.id, " sigcode=", c.sigcode())
	if sig == _SIGSEGV || sig == _SIGBUS {
		print(" addr=", hex(c.fault()))
	}
	print("\n")
	if mp.incgo && gp == mp.g0 && mp.curg != nil {
		print("signal arrived during cgo execution\n")
		// Switch to curg so that we get a traceback of the Go code
		// leading up to the cgocall, which switched from curg to g0.
		gp = mp.curg
	}

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

package main

import (
	"log"
	"runtime/cgo"
	"unsafe"
)

type S struct{ _ cgo.Incomplete }

func main() {
	p := (*S)(unsafe.Pointer(uintptr(0x8000)))
	var v any = p
	p2 := v.(*S)
	if p != p2 {

// run

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

//go:build cgo

package main

import "runtime/cgo"

type NIH struct {
	_ cgo.Incomplete
}

type T struct {
	x *NIH
	p *int
}

var y NIH
var z int

func main() {
	a := []T{{&y, &z}}
	a = append(a, T{&y, &z})
	if a[1].x == nil {

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

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

// Created by cgo -cdefs and converted (by hand) to Go
// ../cmd/cgo/cgo -cdefs defs_linux.go defs1_linux.go defs2_linux.go

package runtime

import "unsafe"

const (
	_EINTR  = 0x4
	_EAGAIN = 0xb
	_ENOMEM = 0xc

	_PROT_NONE  = 0x0
	_PROT_READ  = 0x1
	_PROT_WRITE = 0x2
	_PROT_EXEC  = 0x4

	_MAP_ANON    = 0x20
	_MAP_PRIVATE = 0x2
	_MAP_FIXED   = 0x10

	_MADV_DONTNEED   = 0x4
	_MADV_FREE       = 0x8

[short] skip
[!cgo] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test coverage on cgo code. This test case includes an
# extra empty non-cgo file in the package being checked.

go test -short -cover cgocover4
stdout  'coverage:.*[1-9][0-9.]+%'
! stderr '[^0-9]0\.0%'

-- go.mod --
module cgocover4

go 1.16
-- notcgo.go --
package p
-- p.go --
package p

/*
void
f(void)
{
}
*/
import "C"

// run
//go:build cgo

// Copyright 2021 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 "runtime/cgo"

type A struct {
	B
	_ cgo.Incomplete
}
type B struct{ x byte }
type I interface{ M() *B }

func (p *B) M() *B { return p }

var (
	a A
	i I = &a
)

func main() {

! stdout .
go install builtin unsafe  # Should succeed as no-ops.

# With CGO_ENABLED=0, packages that would have
# an install target with cgo on no longer do.
env GODEBUG=
env CGO_ENABLED=0
go list -f '{{.Target}}' runtime/cgo
! stdout .
go list -export -f '{{.Export}}' runtime/cgo

//
// NOTE: setg_gcc<> assume this clobbers only R10 and R11.
TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
	MOVB	runtime·iscgo(SB),  R10
	CMPBEQ	R10, $0, nocgo
	MOVW	AR0, R11
	SLD	$32, R11
	MOVW	AR1, R11
	MOVD	runtime·tls_g(SB), R10
	MOVD	g, 0(R10)(R11*1)
nocgo:
	RET

// load_g loads the g register from pthread-provided
// thread-local memory, for use after calling externally compiled