The [SetCrashOutput] function allows the user to specify an alternate
file to which the runtime should write its fatal crash report.
It may be used to construct an automated reporting mechanism for all
unexpected crashes, not just those in goroutines that explicitly use

//	return notoc_func();
// }
import "C"
import "testing"

func testPPC64CallStubs(t *testing.T) {
	// Verify the trampolines run on the testing machine. If they
	// do not, or are missing, a crash is expected.
	if C.TestPPC64Stubs() != 0 {
		t.Skipf("This test requires binutils 2.35 or newer.")
	}

}

type dataAndEOFReader string

func (r dataAndEOFReader) Read(p []byte) (int, error) {
	return copy(p, r), io.EOF
}

func TestPeekThenUnreadRune(t *testing.T) {
	// This sequence used to cause a crash.
	r := NewReader(strings.NewReader("x"))
	r.ReadRune()
	r.Peek(1)
	r.UnreadRune()
	r.ReadRune() // Used to panic here
}

var testOutput = []byte("0123456789abcdefghijklmnopqrstuvwxy")

	init bool
}

// NewInt returns a new Int initialized to x.
func NewInt(x int64) *Int { return new(Int).SetInt64(x) }

// Int promises that the zero value is a 0, but in gmp
// the zero value is a crash.  To bridge the gap, the
// init bool says whether this is a valid gmp value.
// doinit initializes z.i if it needs it.  This is not inherent
// to FFI, just a mismatch between Go's convention of

	stringFromGo = s
}

func testCallbackStack(t *testing.T) {
	// Make cgo call and callback with different amount of stack available.
	// We do not do any explicit checks, just ensure that it does not crash.
	for _, f := range splitTests {
		f()
	}
}

//export goStackCheck
func goStackCheck() {
	// use some stack memory to trigger split stack check
	var buf [256]byte
	use(buf[:])
}

	if name == nil || name.Kind != "func" {
		// Probably a type conversion.
		return "", false
	}

	params := name.FuncType.Params
	args := call.Call.Args
	end := call.Call.End()

	// Avoid a crash if the number of arguments doesn't match
	// the number of parameters.
	// This will be caught when the generated file is compiled.
	if len(args) != len(params) {
		return "", false
	}

	any := false

		{data2[:1536] + trash[:1], 1, io.ErrUnexpectedEOF},
		{data2[:1536] + trash[:511], 1, io.ErrUnexpectedEOF},
		{data2[:1536] + trash, 1, ErrHeader},
		{data2[:2048], 1, io.EOF}, // Exactly 1 empty block
		{data2[:2048] + trash[:1], 1, io.ErrUnexpectedEOF},
		{data2[:2048] + trash[:511], 1, io.ErrUnexpectedEOF},
		{data2[:2048] + trash, 1, ErrHeader},

</p>

<p>
If the channel were buffered (e.g., <code>c = make(chan int, 1)</code>)
then the program would not be guaranteed to print
<code>"hello, world"</code>.  (It might print the empty string,
crash, or do something else.)
</p>

<p class="rule">
The <i>k</i>th receive on a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send from that channel completes.
</p>

	LDORLB	R5, (RSP), R7                        // e7336538
	CASD	R1, (R2), ZR                         // 5f7ca1c8
	CASW	R1, (RSP), ZR                        // ff7fa188
	CASB	ZR, (R5), R3                         // a37cbf08
	CASH	R3, (RSP), ZR                        // ff7fa348
	CASW	R5, (R7), R6                         // e67ca588
	CASLD	ZR, (RSP), R8                        // e8ffbfc8
	CASLW	R9, (R10), ZR                        // 5ffda988

pkg syscall (darwin-arm64), const NET_RT_MAXID ideal-int
pkg syscall (darwin-arm64), const NET_RT_STAT = 4
pkg syscall (darwin-arm64), const NET_RT_STAT ideal-int
pkg syscall (darwin-arm64), const NET_RT_TRASH = 5
pkg syscall (darwin-arm64), const NET_RT_TRASH ideal-int
pkg syscall (darwin-arm64), const NOFLSH = 2147483648
pkg syscall (darwin-arm64), const NOFLSH ideal-int
pkg syscall (darwin-arm64), const NOTE_ABSOLUTE = 8