// asmcheck

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

//go:noinline
func f(x int32) {
}

func g(p *int32) {
	// argument marshaling code should live at line 17, not line 15.
	x := *p
	// 386: `MOVL\s[A-Z]+,\s\(SP\)`
	f(x)

// asmcheck

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

// A uint16 or sint16 constant shifted left.
func shifted16BitConstants(out [64]uint64) {
	// ppc64x: "MOVD\t[$]8193,", "SLD\t[$]27,"
	out[0] = 0x0000010008000000
	// ppc64x: "MOVD\t[$]-32767", "SLD\t[$]26,"
	out[1] = 0xFFFFFE0004000000

// asmcheck -gcflags=-spectre=index

//go:build amd64

// Copyright 2020 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 codegen

func IndexArray(x *[10]int, i int) int {
	// amd64:`CMOVQCC`
	return x[i]
}

func IndexString(x string, i int) byte {
	// amd64:`CMOVQ(LS|CC)`
	return x[i]
}

// asmcheck

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

// Make sure we reuse large constant loads, if we can.
// See issue 33580.

package codegen

const (
	A = 7777777777777777
	B = 8888888888888888
)

func f(x, y uint64) uint64 {
	p := x & A
	q := y & A
	r := x & B
	// amd64:-"MOVQ.*8888888888888888"

// asmcheck

// Copyright 2022 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 to make sure that we recognize when the length of an append
// is constant. We check this by making sure that the constant length
// is folded into a load offset.

package p

func f(x []int) int {
	s := make([]int, 3)
	s = append(s, 4, 5)

// asmcheck

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

func main() {
	// amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func3"
	f(1)()

	// amd64:"LEAQ\tcommand-line-arguments\\.main\\.g\\.h\\.func2"
	g(2)()

	// amd64:"LEAQ\tcommand-line-arguments\\.main\\.h\\.func1"
	h(3)()

// asmcheck

// Copyright 2022 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 codegen

type I interface{ M() }

func NopConvertIface(x I) I {
	// amd64:-`.*runtime.convI2I`
	return I(x)
}

func NopConvertGeneric[T any](x T) T {
	// amd64:-`.*runtime.convI2I`
	return T(x)
}

// asmcheck -gcflags=-spectre=ret

//go:build amd64

package codegen

func CallFunc(f func()) {
	// amd64:`CALL\truntime.retpoline`
	f()
}

func CallInterface(x interface{ M() }) {
	// amd64:`CALL\truntime.retpoline`
	x.M()
}

// Check to make sure that jump tables are disabled
// when retpoline is on. See issue 57097.
func noJumpTables(x int) int {
	switch x {
	case 0:
		return 0
	case 1:
		return 1

// asmcheck

// Copyright 2022 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 codegen

func f1(x *[4]int, y *[4]int) {
	// amd64:".*memmove"
	*x = *y
}
func f2(x *[4]int, y [4]int) {
	// amd64:-".*memmove"
	*x = y
}
func f3(x *[4]int, y *[4]int) {
	// amd64:-".*memmove"
	t := *y
	// amd64:-".*memmove"
	*x = t
}

// asmcheck -gcflags=-clobberdead

//go:build amd64 || arm64

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

type T [2]*int // contain pointer, not SSA-able (so locals are not registerized)

var p1, p2, p3 T

func F() {
	// 3735936685 is 0xdeaddead. On ARM64 R27 is REGTMP.