// compile

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

// Issue 4200: 6g crashes when a type is larger than 4GB.

package main

import "unsafe"

// N=16 on 32-bit arches, 256 on 64-bit arches.
// On 32-bit arches we don't want to test types
// that are over 4GB large.
const N = 1 << unsafe.Sizeof(uintptr(0))

package runtime

const (
	_SS_DISABLE  = 2
	_NSIG        = 65
	_SIG_BLOCK   = 0
	_SIG_UNBLOCK = 1
	_SIG_SETMASK = 2
)

// It's hard to tease out exactly how big a Sigset is, but
// rt_sigprocmask crashes if we get it wrong, so if binaries
// are running, this is right.
type sigset [2]uint32

var sigset_all = sigset{^uint32(0), ^uint32(0)}

//go:nosplit
//go:nowritebarrierrec
func sigaddset(mask *sigset, i int) {

# This is a stripped down GraphDef of the model from b/175240312. To hit the
# bug, the GraphDef needs to have functions in the library and also a Merge node
# to go into certain part of the functionalization code where it crashes.

node {
  name: "input"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_BOOL
    }
  }
}
node {
  name: "Switch0"
  op: "Switch"
  input: "input"

// compile

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

// Issue 48916: expand_calls pass crashes due to a (dead)
// use of an OpInvalid value.

package p

type T struct {
	num int64
}

func foo(vs map[T]struct{}, d T) error {
	_, ok := vs[d]
	if !ok {
		return nil
	}

	switch d.num {
	case 0:

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

// Issue 51101: on RISCV64, difference of two pointers
// was marked as pointer and crashes GC.

package main

var a, b int

func main() {
	F(&b, &a)
}

//go:noinline
func F(a, b *int) bool {
	x := a == b
	G(x)
	y := a != b
	return y
}

//go:noinline

// compile

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

// Issue 4529: escape analysis crashes on "go f(g())"
// when g has multiple returns.

package main

type M interface{}

type A struct {
	a string
	b chan M
}

func (a *A) I() (b <-chan M, c chan<- M) {
	a.b, c = make(chan M), make(chan M)
	b = a.b

		// closing it.)
		//
		// The new fd must be close-on-exec, otherwise if the
		// crash monitor is a child process, it may inherit
		// it, so it will never see EOF from the pipe even
		// when this process crashes.
		//
		// A side effect of Fd() is that it calls SetBlocking,
		// which is important so that writes of a crash report
		// to a full pipe buffer don't get lost.
		fd2, _, err := poll.DupCloseOnExec(int(f.Fd()))

func NewI(i int) I {
	return new(S)
}

// Uses interface method.
func Use(x I) {
	x.F()
}

func main() {
	i := NewI(0);
	Use(i);

	// Again, without temporary
	// Crashes because x.F is 0.
	Use(NewI(0));

# 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
}

	dummy := make(chan int)
	v := 0x12345678
	for i := 0; i < 10; i++ {
		// 6g had a bug that caused select to pass &t to
		// selectrecv before allocating the memory for t,
		// which caused non-deterministic crashes.
		// This test looks for the bug by checking that the
		// value received actually ends up in t.
		// If the allocation happens after storing through
		// whatever garbage &t holds, the later reference