// compile

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

// Used to leak registers on 8g.

package p

func f(x byte, y uint64) {
	var r byte
	switch y {
	case 1:
		r = x << y // '>>' triggers it too
	case 2:
		r = x << y
	case 3:
		r = x << y
	case 4:
		r = x << y
	case 5:
		r = x << y
	case 6:

// build

// Copyright 2013 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 5841: 8g produces invalid CMPL $0, $0.
// Similar to issue 5002, used to fail at link time.

package main

func main() {
	var y int
	if y%1 == 0 {
	}

        MemoryAmount.of('512g') | 64      | true   | MemoryAmount.of('32g')
        MemoryAmount.of('8g')   | 64      | true   | MemoryAmount.of('2g')
        MemoryAmount.of('512g') | 64      | false  | MemoryAmount.of('1g')
        MemoryAmount.of('2g')   | 64      | false  | MemoryAmount.of('512m')
        MemoryAmount.of('8g')   | 32      | false  | MemoryAmount.of('1g')
        MemoryAmount.of('2g')   | 32      | false  | MemoryAmount.of('512m')

		},
		"pvc nil and pv filesystem": {
			isExpectedMismatch: false,
			vol:                createVolumeModeFilesystemTestVolume(),
			pvc:                makeVolumeModePVC("8G", nil, nil),
		},
		"pvc nil and pv nil": {
			isExpectedMismatch: false,
			vol:                createVolumeModeNilTestVolume(),
			pvc:                makeVolumeModePVC("8G", nil, nil),
		},

// run

// Test for 8g register move bug.  The optimizer gets confused
// about 16- vs 32-bit moves during splitContractIndex.

// Issue 3910.

package main

func main() {
	const c = 0x12345678
	index, n, offset := splitContractIndex(c)
	if index != int((c&0xffff)>>5) || n != int(c&(1<<5-1)) || offset != (c>>16)&(1<<14-1) {
		println("BUG", index, n, offset)
	}
}

func splitContractIndex(ce uint32) (index, n, offset int) {

// compile

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

// Used to run out of registers on 8g.  Issue 868.

package main

func main() {
	var r uint32
	var buf [4]byte
	a := buf[0:4]
	r = (((((uint32(a[3]) << 8) | uint32(a[2])) << 8) |
		uint32(a[1])) << 8) | uint32(a[0])
	_ = r

// run

// 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 4353. An optimizer bug in 8g triggers a runtime fault
// instead of an out of bounds panic.

package main

var aib [100000]int
var paib *[100000]int = &aib
var i64 int64 = 100023

func main() {
	defer func() { recover() }()
	_ = paib[i64]

// 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 4399: 8g would print "gins LEAQ nil *A".

package main

type A struct{ a int }

func main() {
	println(((*A)(nil)).a)

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

// https://golang.org/issue/806
// triggered out of registers on 8g

package bug283

type Point struct {
	x int
	y int
}

func dist(p0, p1 Point) float64 {
	return float64((p0.x-p1.x)*(p0.x-p1.x) + (p0.y-p1.y)*(p0.y-p1.y))

// build

// Copyright 2013 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 5002: 8g produces invalid CMPL $0, $0.
// Used to fail at link time.

package main

func main() {
	var y int64
	if y%1 == 0 {
	}