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

package main

// Make sure the compiler knows that DUFFCOPY clobbers X0

import "fmt"

//go:noinline
func f(x float64) float64 {
	// y is allocated to X0
	y := x + 5
	// marshals z before y.  Marshaling z
	// calls DUFFCOPY.
	return g(z, y)
}

//go:noinline
func g(b [64]byte, y float64) float64 {
	return y
}

var z [64]byte

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

// Test that we are zeroing directly instead of
// copying a large zero value. Issue 38554.

package codegen

func retlarge() [256]byte {
	// amd64:-"DUFFCOPY"
	return [256]byte{}

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

// Issue 42944: address of callee args area should only be short-lived
// and never across a call.

package p

type T [10]int // trigger DUFFCOPY when passing by value, so it uses the address

func F() {
	var x T
	var i int
	for {
		x = G(i) // no autotmp live at this and next calls
		H(i, x)
	}
}

func G(int) T

	CgoCheckMemmove   *obj.LSym
	CgoCheckPtrWrite  *obj.LSym
	CheckPtrAlignment *obj.LSym
	Deferproc         *obj.LSym
	Deferprocat       *obj.LSym
	DeferprocStack    *obj.LSym
	Deferreturn       *obj.LSym
	Duffcopy          *obj.LSym
	Duffzero          *obj.LSym
	GCWriteBarrier    [8]*obj.LSym
	Goschedguarded    *obj.LSym
	Growslice         *obj.LSym
	InterfaceSwitch   *obj.LSym
	Memmove           *obj.LSym

	REGLINK = REG_R1
	REGSP   = REG_R3
	REGRET  = REG_R20 // not use
	REGARG  = -1      // -1 disables passing the first argument in register
	REGRT1  = REG_R20 // reserved for runtime, duffzero and duffcopy
	REGRT2  = REG_R21 // reserved for runtime, duffcopy
	REGCTXT = REG_R29 // context for closures
	REGG    = REG_R22 // G in loong64
	REGTMP  = REG_R30 // used by the assembler
	FREGRET = REG_F0  // not use
)

	bsink = []byte("012345")

	// 3978425819141910832 = 0x3736353433323130
	// 7306073769690871863 = 0x6564636261393837
	// amd64:`MOVQ\t\$3978425819141910832`,`MOVQ\t\$7306073769690871863`
	//   386:`MOVL\t\$858927408, \(`,`DUFFCOPY`
	// arm64:`MOVD\t\$3978425819141910832`,`MOVD\t\$7306073769690871863`,`MOVD\t\$15`
	//  wasm:`I64Const\t\$3978425819141910832`,`I64Store\t\$0`,`I64Const\t\$7306073769690871863`,`I64Store\t\$7`
	bsink = []byte("0123456789abcde")

	REGSB   = REG_R28
	REGLINK = REG_R31
	REGRET  = REG_R1
	REGARG  = -1      /* -1 disables passing the first argument in register */
	REGRT1  = REG_R1  /* reserved for runtime, duffzero and duffcopy */
	REGRT2  = REG_R2  /* reserved for runtime, duffcopy */
	REGCTXT = REG_R22 /* context for closures */
	REGG    = REG_R30 /* G */
	REGTMP  = REG_R23 /* used by the linker */
	FREGRET = REG_F0
)

// runtime·duffcopy is a Duff's device for copying memory.
// The compiler jumps to computed addresses within
// the routine to copy chunks of memory.
// Source and destination must not overlap.
// Do not change duffcopy without also
// changing the uses in cmd/compile/internal/*/*.go.

// See the zero* and copy* generators below
// for architecture-specific comments.

// mkduff generates duff_*.s.
package main

import (

	{"deferprocStack", 1},
	{"deferreturn", 1},
	{"newproc", 1},
	{"panicoverflow", 1},
	{"sigpanic", 1},

	// compiler backend inserted calls
	{"gcWriteBarrier", 1},
	{"duffzero", 1},
	{"duffcopy", 1},

	// assembler backend inserted calls
	{"morestack", 0},        // asm function, ABI0
	{"morestackc", 0},       // asm function, ABI0
	{"morestack_noctxt", 0}, // asm function, ABI0

	{"runtime.deferreturn", 1},
	{"runtime.newproc", 1},
	{"runtime.panicoverflow", 1},
	{"runtime.sigpanic", 1},
	{"runtime.gcWriteBarrier", 1},
	{"runtime.duffzero", 1},
	{"runtime.duffcopy", 1},
	{"runtime.morestack", 0},
	{"runtime.morestackc", 0},
	{"runtime.morestack_noctxt", 0},
	{"type:int8", 0},
	{"type:*int8", 0},
	{"type:uint8", 0},
	{"type:*uint8", 0},
	{"type:int16", 0},