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

// Check for cycles in a pointer literal's method call.

package ptrlitmethcall

type T int

func (*T) pm() int {
	_ = x
	return 0
}

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

// issue 7366: generates a temporary with ideal type
// during comparison of small structs.

package main

type T struct {
	data [10]byte
}

func main() {
	var a T
	var b T
	if a == b {
	}

// 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 7150: array index out of bounds error off by one

package main

func main() {
	_ = [0]int{-1: 50}              // ERROR "index must be non-negative integer constant|index expression is negative|must not be negative"

// runoutput

// 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 7316
// This test exercises all types of numeric conversions, which was one
// of the sources of etype mismatch during register allocation in 8g.

package main

import "fmt"

const tpl = `
func init() {
	var i %s
	j := %s(i)
	_ = %s(j)
}
`

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

// Some uses of zeroed constants in non-assignment
// expressions broke with our more aggressive zeroing
// of assignments (internal compiler errors).

package main

func f1() {
	type T [2]int
	p := T{0, 1}
	switch p {
	case T{0, 0}:
		panic("wrong1")

// 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 (ppc64 || ppc64le) && gc

#include "textflag.h"

TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0
	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), R1

	// Ask signaller to setgid
	MOVW	$1, R3

// 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 race && (darwin || freebsd || linux)

package race_test

import (
	"sync/atomic"
	"syscall"
	"testing"
	"unsafe"
)

// Test that race detector does not crash when accessing non-Go allocated memory (issue 9136).
func TestNonGoMemory(t *testing.T) {

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

// Issue 7405: the equality function for struct with many
// embedded fields became more complex after fixing issue 7366,
// leading to out of registers on 386.

package p

type T1 struct {
	T2
	T3
	T4
}

type T2 struct {
	Conn
}

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

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

static pthread_t thread;

static void* threadfunc(void* dummy) {
	while(1) {
		sleep(1);
	}
}

int StartThread() {
	return pthread_create(&thread, NULL, &threadfunc, NULL);
}

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

#include "textflag.h"

//
// System calls for aix/ppc64 are implemented in ../runtime/syscall_aix.go
//

TEXT ·syscall6(SB),NOSPLIT,$0
	JMP	runtime·syscall_syscall6(SB)

TEXT ·rawSyscall6(SB),NOSPLIT,$0
	JMP	runtime·syscall_rawSyscall6(SB)

TEXT ·RawSyscall(SB),NOSPLIT,$0