// compile

// Copyright 2016 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 17918: slice out-of-bounds in ssa/cse

package dead

import (
	"fmt"
	"time"
)

var (
	units = []struct {
		divisor time.Duration
		unit    rune
	}{
		{1000000, 's'},
		{60, 'm'},
		{60, 'h'},
		{24, 'd'},
		{7, 'w'},
	}

// compile -d=ssa/check/on

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

package p

var i int

type t struct {
	a, b, c, d, e int
}

func f(p t, q int) int {
	var a, b, c, d, e, f, g int
	var h, i, j, k, l, m int
	_, _, _, _, _, _, _ = a, b, c, d, e, f, g
	_, _, _, _, _, _ = h, i, j, k, l, m
	return 0
}

// errorcheck -0 -d=ssa/intrinsics/debug

//go:build amd64 || arm64 || loong64 || mips || mipsle || mips64 || mips64le || ppc64 || ppc64le || riscv64 || s390x

// Copyright 2016 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 main

import "sync/atomic"

var x uint32

func atomics() {

// Copyright 2015 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 ssa

type ID int32

// idAlloc provides an allocator for unique integers.
type idAlloc struct {
	last ID
}

// get allocates an ID and returns it. IDs are always > 0.
func (a *idAlloc) get() ID {
	x := a.last
	x++
	if x == 1<<31-1 {

}
func (fap fileAndPairs) Less(i, j int) bool {
	return fap[i].f < fap[j].f
}
func (fap fileAndPairs) Swap(i, j int) {
	fap[i], fap[j] = fap[j], fap[i]
}

// -d=ssa/number_lines/stats=1 (that bit) for line and file distribution statistics
// -d=ssa/number_lines/debug for information about why particular values are marked as statements.
func numberLines(f *Func) {
	po := f.Postorder()
	endlines := make(map[ID]src.XPos)

// compile -d=ssa/check/seed=1

// Copyright 2023 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 main

func F[G int]() int {
	return len(make([]int, copy([]G{}, []G{})))
}

func main() {
	F[int]()

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

// Used to crash when compiling assignments involving [0]T,
// where T is not SSA-able.

package a

func f() {
	var i int
	arr := [0][2]int{}
	arr[i][0] = 0

// license that can be found in the LICENSE file.

// Values smaller than 64-bits were mistakenly always proven to be
// non-negative.
//
// The tests here are marked go:noinline to ensure they're
// independently optimized by SSA.

package main

var x int32 = -1

//go:noinline
func a() {
	if x != -1 {
		panic(1)
	}
	if x > 0 || x != -1 {
		panic(2)
	}
}

//go:noinline
func b() {
	if x != -1 {

// run

// Copyright 2016 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 that we do loads exactly once. The SSA backend
// once tried to do the load in f twice, once sign extended
// and once zero extended.  This can cause problems in
// racy code, particularly sync/mutex.

package main

func f(p *byte) bool {
	x := *p

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

// Used to crash when compiling assignments involving [0]T,
// where T is not SSA-able.

package p

type s struct {
	a, b, c, d, e int
}

func f() {
	var i int
	arr := [0]s{}
	arr[i].a++