test/codegen/memops.go

// asmcheck

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

import "unsafe"

//go:linkname memequal runtime.memequal
func memequal(a, b unsafe.Pointer, size uintptr) bool

func Equal1Constant(p unsafe.Pointer) bool {
	// 386:`CMPB` -`.*memequal.*`
	return memequal(p, unsafe.Pointer(unsafe.StringData("a")), 1)
}

func Equal4Constant(p unsafe.Pointer) bool {
	// 386:`CMPL` -`.*memequal.*`
	return memequal(unsafe.Pointer(unsafe.StringData("abcd")), p, 4)
}

func Equal8Constant(p unsafe.Pointer) bool {
	// wasm:`I64Eq` -`.*memequal.*`
	return memequal(p, unsafe.Pointer(unsafe.StringData("abcdefgh")), 8)
}

func Equal5Constant(p unsafe.Pointer) bool {
	// wasm:`I64Eq` -`.*memequal.*`
	return memequal(unsafe.Pointer(unsafe.StringData("abcde")), p, 5)
}

var x [2]bool
var x8 [2]uint8
var x16 [2]uint16
var x32 [2]uint32
var x64 [2]uint64

func compMem1() int {
	// amd64:`CMPB command-line-arguments.x\+1\(SB\), [$]0`
	if x[1] {
		return 1
	}
	// amd64:`CMPB command-line-arguments.x8\+1\(SB\), [$]7`
	if x8[1] == 7 {
		return 1
	}
	// amd64:`CMPW command-line-arguments.x16\+2\(SB\), [$]7`
	if x16[1] == 7 {
		return 1
	}
	// amd64:`CMPL command-line-arguments.x32\+4\(SB\), [$]7`
	if x32[1] == 7 {
		return 1
	}
	// amd64:`CMPQ command-line-arguments.x64\+8\(SB\), [$]7`
	if x64[1] == 7 {
		return 1
	}
	return 0
}

type T struct {
	x   bool
	x8  uint8
	x16 uint16
	x32 uint32
	x64 uint64
	a   [2]int // force it passed in memory
}

func compMem2(t T) int {
	// amd64:`CMPB .*\(SP\), [$]0`
	if t.x {
		return 1
	}
	// amd64:`CMPB .*\(SP\), [$]7`
	if t.x8 == 7 {
		return 1
	}
	// amd64:`CMPW .*\(SP\), [$]7`
	if t.x16 == 7 {
		return 1
	}
	// amd64:`CMPL .*\(SP\), [$]7`
	if t.x32 == 7 {
		return 1
	}
	// amd64:`CMPQ .*\(SP\), [$]7`
	if t.x64 == 7 {
		return 1
	}
	return 0
}

func compMem3(x, y *int) (int, bool) {
	// We can do comparisons of a register with memory even if
	// the register is used subsequently.
	r := *x
	// amd64:`CMPQ \(`
	// 386:`CMPL \(`
	return r, r < *y
}

// The following functions test that indexed load/store operations get generated.

func idxInt8(x, y []int8, i int) {
	var t int8
	// amd64: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
	//   386: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
	t = x[i+1]
	// amd64: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	//   386: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	y[i+1] = t
	// amd64: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	//   386: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[i+1] = 77
}

func idxInt16(x, y []int16, i int) {
	var t int16
	// amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
	//   386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
	t = x[i+1]
	// amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	//   386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	y[i+1] = t
	// amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
	//   386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
	t = x[16*i+1]
	// amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
	//   386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
	y[16*i+1] = t
	// amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	//   386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	x[i+1] = 77
	// amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
	//   386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
	x[16*i+1] = 77
}

func idxInt32(x, y []int32, i int) {
	var t int32
	// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	//   386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	t = x[i+1]
	// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	//   386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	y[i+1] = t
	// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	t = x[2*i+1]
	// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	y[2*i+1] = t
	// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
	//   386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
	t = x[16*i+1]
	// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
	//   386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
	y[16*i+1] = t
	// amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	//   386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+1] = 77
	// amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
	//   386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
	x[16*i+1] = 77
}

func idxInt64(x, y []int64, i int) {
	var t int64
	// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	t = x[i+1]
	// amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	y[i+1] = t
	// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
	t = x[16*i+1]
	// amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
	y[16*i+1] = t
	// amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+1] = 77
	// amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
	x[16*i+1] = 77
}

func zero64(x *uint64) {
	// amd64: `MOVQ X15, \([A-Z]+[0-9]*\)`
	*x = 0
}

func zero32Direct(x *uint32) {
	// amd64: `MOVL X15, \([A-Z]+[0-9]*\)`
	*x = 0
}

func zeroIdx8(x []int64, i int) {
	// amd64: `MOVQ X15, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i] = 0
}

func zeroIdx1(x []int64, i int) {
	// amd64: `MOVQ X15, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[16*i] = 0
}

func zero32(x []uint32, i int) {
	// amd64: `MOVL X15, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i] = 0
}

func zero32Idx1(x []uint32, i int) {
	// amd64: `MOVL X15, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[4*i] = 0
}

func idxFloat32(x, y []float32, i int) {
	var t float32
	//    amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
	// 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
	//    arm64: `FMOVS \(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+`
	t = x[i+1]
	//    amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	// 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	//    arm64: `FMOVS F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)`
	y[i+1] = t
	//    amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
	// 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
	t = x[16*i+1]
	//    amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
	// 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
	y[16*i+1] = t
}

func idxFloat64(x, y []float64, i int) {
	var t float64
	//    amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
	// 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
	//    arm64: `FMOVD \(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+`
	t = x[i+1]
	//    amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	// 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	//    arm64: `FMOVD F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)`
	y[i+1] = t
	//    amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
	// 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
	t = x[16*i+1]
	//    amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
	// 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
	y[16*i+1] = t
}

func idxLoadPlusOp32(x []int32, i int) int32 {
	s := x[0]
	// 386: `ADDL 4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
	// amd64: `ADDL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	s += x[i+1]
	// 386: `SUBL 8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
	// amd64: `SUBL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	s -= x[i+2]
	// 386: `IMULL 12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
	s *= x[i+3]
	// 386: `ANDL 16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
	// amd64: `ANDL 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	s &= x[i+4]
	// 386: `ORL 20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
	// amd64: `ORL 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	s |= x[i+5]
	// 386: `XORL 24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
	// amd64: `XORL 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	s ^= x[i+6]
	return s
}

func idxLoadPlusOp64(x []int64, i int) int64 {
	s := x[0]
	// amd64: `ADDQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	s += x[i+1]
	// amd64: `SUBQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	s -= x[i+2]
	// amd64: `ANDQ 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	s &= x[i+3]
	// amd64: `ORQ 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	s |= x[i+4]
	// amd64: `XORQ 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	s ^= x[i+5]
	return s
}

func idxStorePlusOp32(x []int32, i int, v int32) {
	// 386: `ADDL [A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `ADDL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+1] += v
	// 386: `SUBL [A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `SUBL [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+2] -= v
	// 386: `ANDL [A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `ANDL [A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+3] &= v
	// 386: `ORL [A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `ORL [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+4] |= v
	// 386: `XORL [A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `XORL [A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+5] ^= v

	// 386: `ADDL [$]77, 24\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `ADDL [$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+6] += 77
	// 386: `ANDL [$]77, 28\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `ANDL [$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+7] &= 77
	// 386: `ORL [$]77, 32\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `ORL [$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+8] |= 77
	// 386: `XORL [$]77, 36\([A-Z]+\)\([A-Z]+\*4\)`
	// amd64: `XORL [$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
	x[i+9] ^= 77
}

func idxStorePlusOp64(x []int64, i int, v int64) {
	// amd64: `ADDQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+1] += v
	// amd64: `SUBQ [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+2] -= v
	// amd64: `ANDQ [A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+3] &= v
	// amd64: `ORQ [A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+4] |= v
	// amd64: `XORQ [A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+5] ^= v

	// amd64: `ADDQ [$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+6] += 77
	// amd64: `ANDQ [$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+7] &= 77
	// amd64: `ORQ [$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+8] |= 77
	// amd64: `XORQ [$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
	x[i+9] ^= 77
}

func idxCompare(i int) int {
	// amd64: `MOVBLZX 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
	if x8[i+1] < x8[0] {
		return 0
	}
	// amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
	if x16[i+1] < x16[0] {
		return 0
	}
	// amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
	if x16[16*i+1] < x16[0] {
		return 0
	}
	// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	if x32[i+1] < x32[0] {
		return 0
	}
	// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
	if x32[16*i+1] < x32[0] {
		return 0
	}
	// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	if x64[i+1] < x64[0] {
		return 0
	}
	// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
	if x64[16*i+1] < x64[0] {
		return 0
	}
	// amd64: `MOVBLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
	if x8[i+2] < 77 {
		return 0
	}
	// amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
	if x16[i+2] < 77 {
		return 0
	}
	// amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
	if x16[16*i+2] < 77 {
		return 0
	}
	// amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
	if x32[i+2] < 77 {
		return 0
	}
	// amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
	if x32[16*i+2] < 77 {
		return 0
	}
	// amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
	if x64[i+2] < 77 {
		return 0
	}
	// amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
	if x64[16*i+2] < 77 {
		return 0
	}
	return 1
}

func idxFloatOps(a []float64, b []float32, i int) (float64, float32) {
	c := float64(7)
	// amd64: `ADDSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
	c += a[i+1]
	// amd64: `SUBSD 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
	c -= a[i+2]
	// amd64: `MULSD 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
	c *= a[i+3]
	// amd64: `DIVSD 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
	c /= a[i+4]

	d := float32(8)
	// amd64: `ADDSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
	d += b[i+1]
	// amd64: `SUBSS 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
	d -= b[i+2]
	// amd64: `MULSS 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
	d *= b[i+3]
	// amd64: `DIVSS 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
	d /= b[i+4]
	return c, d
}

func storeTest(a []bool, v int, i int) {
	// amd64: `BTL \$0,` `SETCS 4\([A-Z]+[0-9]*\)`
	a[4] = v&1 != 0
	// amd64: `BTL \$1,` `SETCS 3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	a[3+i] = v&2 != 0
}

func bitOps(p *[12]uint64) {
	// amd64: `ORQ \$8, \(AX\)`
	p[0] |= 8
	// amd64: `ORQ \$1073741824, 8\(AX\)`
	p[1] |= 1 << 30
	// amd64: `BTSQ \$31, 16\(AX\)`
	p[2] |= 1 << 31
	// amd64: `BTSQ \$63, 24\(AX\)`
	p[3] |= 1 << 63

	// amd64: `ANDQ \$-9, 32\(AX\)`
	p[4] &^= 8
	// amd64: `ANDQ \$-1073741825, 40\(AX\)`
	p[5] &^= 1 << 30
	// amd64: `BTRQ \$31, 48\(AX\)`
	p[6] &^= 1 << 31
	// amd64: `BTRQ \$63, 56\(AX\)`
	p[7] &^= 1 << 63

	// amd64: `XORQ \$8, 64\(AX\)`
	p[8] ^= 8
	// amd64: `XORQ \$1073741824, 72\(AX\)`
	p[9] ^= 1 << 30
	// amd64: `BTCQ \$31, 80\(AX\)`
	p[10] ^= 1 << 31
	// amd64: `BTCQ \$63, 88\(AX\)`
	p[11] ^= 1 << 63
}

func constModify8(p *[8]uint8) {
	// amd64: `INCB \([A-Z]+[0-9]*\)` -`MOVB`
	p[0]++
	// amd64: `DECB 1\([A-Z]+[0-9]*\)` -`MOVB`
	p[1]--
	// amd64: `ADDB [$]77, 2\([A-Z]+[0-9]*\)` -`MOVB`
	p[2] += 77
	// amd64: `ANDB [$]77, 3\([A-Z]+[0-9]*\)` -`MOVB`
	p[3] &= 77
	// amd64: `ORB [$]12, 4\([A-Z]+[0-9]*\)` -`MOVB`
	p[4] |= 12
	// amd64: `ANDB [$]-13, 5\([A-Z]+[0-9]*\)` -`MOVB`
	p[5] &^= 12
	// amd64: `XORB [$]12, 6\([A-Z]+[0-9]*\)` -`MOVB`
	p[6] ^= 12
}

func constModify16(p *[8]uint16) {
	// amd64: `INCW \([A-Z]+[0-9]*\)` -`MOVW`
	p[0]++
	// amd64: `DECW 2\([A-Z]+[0-9]*\)` -`MOVW`
	p[1]--
	// amd64: `ADDW [$]77, 4\([A-Z]+[0-9]*\)` -`MOVW`
	p[2] += 77
	// amd64: `ANDW [$]77, 6\([A-Z]+[0-9]*\)` -`MOVW`
	p[3] &= 77
	// amd64: `ORW [$]12, 8\([A-Z]+[0-9]*\)` -`MOVW`
	p[4] |= 12
	// amd64: `ANDW [$]-13, 10\([A-Z]+[0-9]*\)` -`MOVW`
	p[5] &^= 12
	// amd64: `XORW [$]12, 12\([A-Z]+[0-9]*\)` -`MOVW`
	p[6] ^= 12
}

// Constants that do not fit in an 8-bit immediate keep the
// load/modify/store form rather than growing a 16-bit immediate.
func constModify16Wide(p *uint16) {
	// amd64: -`ORW [$]`
	*p |= 0x1234
}

func constModifyGlobal() {
	// amd64: `ORB [$]12, command-line-arguments\.x8\+1\(SB\)` -`MOVB`
	x8[1] |= 12
	// amd64: `XORW [$]12, command-line-arguments\.x16\+2\(SB\)` -`MOVW`
	x16[1] ^= 12
}

func idxStorePlusOpConst8(x []uint8, i int) {
	// amd64: `INCB 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` -`MOVB`
	x[i+1]++
	// amd64: `DECB 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[i+2]--
	// amd64: `ADDB [$]77, 3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[i+3] += 77
	// amd64: `ANDB [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[i+4] &= 77
	// amd64: `ORB [$]77, 5\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[i+5] |= 77
	// amd64: `XORB [$]77, 6\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
	x[i+6] ^= 77
}

func idxStorePlusOpConst16(x []uint16, i int) {
	// amd64: `INCW 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)` -`MOVW`
	x[i+1]++
	// amd64: `DECW 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	x[i+2]--
	// amd64: `ADDW [$]77, 6\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	x[i+3] += 77
	// amd64: `ANDW [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	x[i+4] &= 77
	// amd64: `ORW [$]77, 10\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	x[i+5] |= 77
	// amd64: `XORW [$]77, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
	x[i+6] ^= 77
}

func idxStorePlusOpConst16Idx1(b []byte, i int) {
	v := uint16(b[i]) | uint16(b[i+1])<<8
	v += 77
	// amd64: `ADDW [$]77, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` -`MOVW`
	b[i] = byte(v)
	b[i+1] = byte(v >> 8)

	v = uint16(b[i+2]) | uint16(b[i+3])<<8
	v &^= 12
	// amd64: `ANDW [$]-13, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` -`MOVW`
	b[i+2] = byte(v)
	b[i+3] = byte(v >> 8)

	v = uint16(b[i+4]) | uint16(b[i+5])<<8
	v |= 77
	// amd64: `ORW [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` -`MOVW`
	b[i+4] = byte(v)
	b[i+5] = byte(v >> 8)

	v = uint16(b[i+6]) | uint16(b[i+7])<<8
	v ^= 77
	// amd64: `XORW [$]77, 6\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)` -`MOVW`
	b[i+6] = byte(v)
	b[i+7] = byte(v >> 8)
}