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

// Export guts for testing.

package runtime

import "unsafe"

const MaxArgs = maxArgs

var (
	OsYield                 = osyield
	TimeBeginPeriodRetValue = &timeBeginPeriodRetValue
)

func NumberOfProcessors() int32 {
	var info systeminfo

// Copyright 2014 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 gccgo

package issue9400

import (
	"runtime"
	"sync/atomic"
)

// The test for the gc compiler resets the stack pointer so that the
// stack gets modified.  We don't have a way to do that for gccgo
// without writing more assembly code, which we haven't bothered to

// Copyright 2014 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 (freebsd && amd64) || (freebsd && arm64) || (freebsd && riscv64)

package syscall

import "unsafe"

func (any *anyMessage) parseRouteMessage(b []byte) *RouteMessage {
	p := (*RouteMessage)(unsafe.Pointer(any))

// errorcheck

// Copyright 2014 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 6671: Logical operators should produce untyped bool for untyped operands.

package p

type mybool bool

func _(x, y int) {
	type mybool bool
	var b mybool
	_ = b
	b = bool(true)             // ERROR "cannot use"

// Copyright 2014 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 (freebsd && 386) || (freebsd && arm)

package syscall

import "unsafe"

func (any *anyMessage) parseRouteMessage(b []byte) *RouteMessage {
	p := (*RouteMessage)(unsafe.Pointer(any))
	off := int(unsafe.Offsetof(p.Header.Rmx)) + SizeofRtMetrics
	if freebsdConfArch == "amd64" {

// run

// Copyright 2014 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 8036. Stores necessary for stack scan being eliminated as redundant by optimizer.

package main

import "runtime"

type T struct {
	X *int
	Y *int
	Z *int
}

type TI [3]uintptr

//go:noinline
func G() (t TI) {
	t[0] = 1
	t[1] = 2

// errorcheck

// Copyright 2014 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 7675: fewer errors for wrong argument count

package p

func f(string, int, float64, string)

func g(string, int, float64, ...string)

func main() {
	f(1, 0.5, "hello") // ERROR "not enough arguments|incompatible type"
	f("1", 2, 3.1, "4")

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

void foo()
{

// Copyright 2014 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 cgotest

//void testHandleLeaks();
import "C"

import (
	"syscall"
	"testing"
	"unsafe"
)

var issue8517counter int

var (
	kernel32              = syscall.MustLoadDLL("kernel32.dll")
	getProcessHandleCount = kernel32.MustFindProc("GetProcessHandleCount")

// compile

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

// /tmp/x.go:3: internal error: f &p (type *int) recorded as live on entry

package p

func f(ch chan int) *int {
	select {
	case p1x := <-ch:
		return &p1x
	default:
		// ok
	}
	select {
	case p1 := <-ch:
		return &p1
	default:
		// ok
	}