// asmcheck

// Copyright 2024 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 x = func() int {
	n := 0
	f(&n)
	return n
}()

func f(p *int) {
	*p = 1
}

var y = 1

// z can be static initialized.
//
// amd64:-"MOVQ"

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

func dgemmSerialNotNot(m, n, k int, a []float64, lda int, b []float64, ldb int, c []float64, ldc int, alpha float64) {
	for i := 0; i < m; i++ {
		ctmp := c[i*ldc : i*ldc+n]
		for l, v := range a[i*lda : i*lda+k] {
			tmp := alpha * v
			if tmp != 0 {

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

// Make sure this code doesn't generate spill/restore.

package codegen

func pack20(in *[20]uint64) uint64 {
	var out uint64
	out |= 4
	// amd64:-`.*SP.*`
	out |= in[0] << 4
	// amd64:-`.*SP.*`
	out |= in[1] << 7
	// amd64:-`.*SP.*`
	out |= in[2] << 10

// asmcheck

//go:build !goexperiment.cgocheck2

// Copyright 2018 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

// This file contains code generation tests related to the handling of
// struct types.

// ------------- //
//    Zeroing    //
// ------------- //

type Z1 struct {
	a, b, c int
}

// 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 issue63332(c chan int) {
	x := 0
	// amd64:-`MOVQ`
	x += 2
	c <- 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

func combine2string(p *[2]string, a, b string) {
	// amd64:`.*runtime[.]gcWriteBarrier4\(SB\)`
	// arm64:`.*runtime[.]gcWriteBarrier4\(SB\)`
	p[0] = a
	// amd64:-`.*runtime[.]gcWriteBarrier`
	// arm64:-`.*runtime[.]gcWriteBarrier`
	p[1] = b
}

// asmcheck

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

// Don't allow 0 masks in shift lowering rules on ppc64x.
// See issue 42610.

package codegen

func f32(a []int32, i uint32) {
        g := func(p int32) int32 {
                i = uint32(p) * (uint32(p) & (i & 1))
                return 1
        }

// asmcheck

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

// These tests check that atomic instructions without dynamic checks are
// generated for architectures that support them

package codegen

import "sync/atomic"

type Counter struct {
	count int32
}

func (c *Counter) Increment() {

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