src/cmd/compile/internal/ssa/rewrite/dec/rewritedec.go

// Code generated from _gen/dec.rules using 'go generate'; DO NOT EDIT.

package dec

import "cmd/compile/internal/types"
import "cmd/compile/internal/ssa/ssaop"
import "cmd/compile/internal/ssa"

func RewriteValue(v *ssa.Value) bool {
	switch v.Op {
	case ssaop.OpArrayMake1:
		return rewriteValue_OpArrayMake1(v)
	case ssaop.OpArraySelect:
		return rewriteValue_OpArraySelect(v)
	case ssaop.OpComplexImag:
		return rewriteValue_OpComplexImag(v)
	case ssaop.OpComplexReal:
		return rewriteValue_OpComplexReal(v)
	case ssaop.OpIData:
		return rewriteValue_OpIData(v)
	case ssaop.OpIMake:
		return rewriteValue_OpIMake(v)
	case ssaop.OpITab:
		return rewriteValue_OpITab(v)
	case ssaop.OpLoad:
		return rewriteValue_OpLoad(v)
	case ssaop.OpSliceCap:
		return rewriteValue_OpSliceCap(v)
	case ssaop.OpSliceLen:
		return rewriteValue_OpSliceLen(v)
	case ssaop.OpSlicePtr:
		return rewriteValue_OpSlicePtr(v)
	case ssaop.OpSlicePtrUnchecked:
		return rewriteValue_OpSlicePtrUnchecked(v)
	case ssaop.OpStore:
		return rewriteValue_OpStore(v)
	case ssaop.OpStringLen:
		return rewriteValue_OpStringLen(v)
	case ssaop.OpStringPtr:
		return rewriteValue_OpStringPtr(v)
	case ssaop.OpStructMake:
		return rewriteValue_OpStructMake(v)
	case ssaop.OpStructSelect:
		return rewriteValue_OpStructSelect(v)
	}
	return false
}
func rewriteValue_OpArrayMake1(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (ArrayMake1 x)
	// cond: x.Type.IsPtrShaped()
	// result: x
	for {
		x := v_0
		if !(x.Type.IsPtrShaped()) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpArraySelect(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (ArraySelect [0] x)
	// cond: x.Type.IsPtrShaped()
	// result: x
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
			break
		}
		x := v_0
		if !(x.Type.IsPtrShaped()) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (ArraySelect (ArrayMake1 x))
	// result: x
	for {
		if v_0.Op != ssaop.OpArrayMake1 {
			break
		}
		x := v_0.Args[0]
		v.CopyOf(x)
		return true
	}
	// match: (ArraySelect [0] (IData x))
	// result: (IData x)
	for {
		if ssa.AuxIntToInt64(v.AuxInt) != 0 || v_0.Op != ssaop.OpIData {
			break
		}
		x := v_0.Args[0]
		v.Reset(ssaop.OpIData)
		v.AddArg(x)
		return true
	}
	// match: (ArraySelect [i] x:(Load <t> ptr mem))
	// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.Elem().Size()*i] ptr) mem)
	for {
		i := ssa.AuxIntToInt64(v.AuxInt)
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, v.Type)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, v.Type.PtrTo())
		v1.AuxInt = ssa.Int64ToAuxInt(t.Elem().Size() * i)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func rewriteValue_OpComplexImag(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (ComplexImag (ComplexMake _ imag ))
	// result: imag
	for {
		if v_0.Op != ssaop.OpComplexMake {
			break
		}
		imag := v_0.Args[1]
		v.CopyOf(imag)
		return true
	}
	// match: (ComplexImag x:(Load <t> ptr mem))
	// cond: t.IsComplex() && t.Size() == 8
	// result: @x.Block (Load <typ.Float32> (OffPtr <typ.Float32Ptr> [4] ptr) mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsComplex() && t.Size() == 8) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float32)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Float32Ptr)
		v1.AuxInt = ssa.Int64ToAuxInt(4)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	// match: (ComplexImag x:(Load <t> ptr mem))
	// cond: t.IsComplex() && t.Size() == 16
	// result: @x.Block (Load <typ.Float64> (OffPtr <typ.Float64Ptr> [8] ptr) mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsComplex() && t.Size() == 16) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float64)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Float64Ptr)
		v1.AuxInt = ssa.Int64ToAuxInt(8)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func rewriteValue_OpComplexReal(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (ComplexReal (ComplexMake real _ ))
	// result: real
	for {
		if v_0.Op != ssaop.OpComplexMake {
			break
		}
		real := v_0.Args[0]
		v.CopyOf(real)
		return true
	}
	// match: (ComplexReal x:(Load <t> ptr mem))
	// cond: t.IsComplex() && t.Size() == 8
	// result: @x.Block (Load <typ.Float32> ptr mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsComplex() && t.Size() == 8) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float32)
		v.CopyOf(v0)
		v0.AddArg2(ptr, mem)
		return true
	}
	// match: (ComplexReal x:(Load <t> ptr mem))
	// cond: t.IsComplex() && t.Size() == 16
	// result: @x.Block (Load <typ.Float64> ptr mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsComplex() && t.Size() == 16) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float64)
		v.CopyOf(v0)
		v0.AddArg2(ptr, mem)
		return true
	}
	return false
}
func rewriteValue_OpIData(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (IData (IMake _ data))
	// cond: data.Op != ssaop.OpStructMake && data.Op != ssaop.OpArrayMake1
	// result: data
	for {
		if v_0.Op != ssaop.OpIMake {
			break
		}
		data := v_0.Args[1]
		if !(data.Op != ssaop.OpStructMake && data.Op != ssaop.OpArrayMake1) {
			break
		}
		v.CopyOf(data)
		return true
	}
	// match: (IData x:(Load <t> ptr mem))
	// cond: t.IsInterface()
	// result: @x.Block (Load <typ.BytePtr> (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr) mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsInterface()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.BytePtr)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtrPtr)
		v1.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func rewriteValue_OpIMake(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (IMake _typ (StructMake ___))
	// result: ssa.ImakeOfStructMake(v)
	for {
		if v_1.Op != ssaop.OpStructMake {
			break
		}
		v.CopyOf(ssa.ImakeOfStructMake(v))
		return true
	}
	// match: (IMake _typ (ArrayMake1 val))
	// result: (IMake _typ val)
	for {
		_typ := v_0
		if v_1.Op != ssaop.OpArrayMake1 {
			break
		}
		val := v_1.Args[0]
		v.Reset(ssaop.OpIMake)
		v.AddArg2(_typ, val)
		return true
	}
	return false
}
func rewriteValue_OpITab(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (ITab (IMake itab _))
	// result: itab
	for {
		if v_0.Op != ssaop.OpIMake {
			break
		}
		itab := v_0.Args[0]
		v.CopyOf(itab)
		return true
	}
	// match: (ITab x:(Load <t> ptr mem))
	// cond: t.IsInterface()
	// result: @x.Block (Load <typ.Uintptr> ptr mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsInterface()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Uintptr)
		v.CopyOf(v0)
		v0.AddArg2(ptr, mem)
		return true
	}
	return false
}
func rewriteValue_OpLoad(v *ssa.Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Load <t> ptr mem)
	// cond: t.IsComplex() && t.Size() == 8
	// result: (ComplexMake (Load <typ.Float32> ptr mem) (Load <typ.Float32> (OffPtr <typ.Float32Ptr> [4] ptr) mem) )
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsComplex() && t.Size() == 8) {
			break
		}
		v.Reset(ssaop.OpComplexMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float32)
		v0.AddArg2(ptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float32)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Float32Ptr)
		v2.AuxInt = ssa.Int64ToAuxInt(4)
		v2.AddArg(ptr)
		v1.AddArg2(v2, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (Load <t> ptr mem)
	// cond: t.IsComplex() && t.Size() == 16
	// result: (ComplexMake (Load <typ.Float64> ptr mem) (Load <typ.Float64> (OffPtr <typ.Float64Ptr> [8] ptr) mem) )
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsComplex() && t.Size() == 16) {
			break
		}
		v.Reset(ssaop.OpComplexMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float64)
		v0.AddArg2(ptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Float64)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Float64Ptr)
		v2.AuxInt = ssa.Int64ToAuxInt(8)
		v2.AddArg(ptr)
		v1.AddArg2(v2, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (Load <t> ptr mem)
	// cond: t.IsString()
	// result: (StringMake (Load <typ.BytePtr> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem))
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsString()) {
			break
		}
		v.Reset(ssaop.OpStringMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.BytePtr)
		v0.AddArg2(ptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v2.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v2.AddArg(ptr)
		v1.AddArg2(v2, mem)
		v.AddArg2(v0, v1)
		return true
	}
	// match: (Load <t> ptr mem)
	// cond: t.IsSlice()
	// result: (SliceMake (Load <t.Elem().PtrTo()> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [2*config.PtrSize] ptr) mem))
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsSlice()) {
			break
		}
		v.Reset(ssaop.OpSliceMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t.Elem().PtrTo())
		v0.AddArg2(ptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v2.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v2.AddArg(ptr)
		v1.AddArg2(v2, mem)
		v3 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int)
		v4 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v4.AuxInt = ssa.Int64ToAuxInt(2 * config.PtrSize)
		v4.AddArg(ptr)
		v3.AddArg2(v4, mem)
		v.AddArg3(v0, v1, v3)
		return true
	}
	// match: (Load <t> ptr mem)
	// cond: t.IsInterface()
	// result: (IMake (Load <typ.Uintptr> ptr mem) (Load <typ.BytePtr> (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr) mem))
	for {
		t := v.Type
		ptr := v_0
		mem := v_1
		if !(t.IsInterface()) {
			break
		}
		v.Reset(ssaop.OpIMake)
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Uintptr)
		v0.AddArg2(ptr, mem)
		v1 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.BytePtr)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtrPtr)
		v2.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v2.AddArg(ptr)
		v1.AddArg2(v2, mem)
		v.AddArg2(v0, v1)
		return true
	}
	return false
}
func rewriteValue_OpSliceCap(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (SliceCap (SliceMake _ _ cap))
	// result: cap
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		cap := v_0.Args[2]
		v.CopyOf(cap)
		return true
	}
	// match: (SliceCap x:(Load <t> ptr mem))
	// cond: t.IsSlice()
	// result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [2*config.PtrSize] ptr) mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsSlice()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v1.AuxInt = ssa.Int64ToAuxInt(2 * config.PtrSize)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func rewriteValue_OpSliceLen(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (SliceLen (SliceMake _ len _))
	// result: len
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		len := v_0.Args[1]
		v.CopyOf(len)
		return true
	}
	// match: (SliceLen x:(Load <t> ptr mem))
	// cond: t.IsSlice()
	// result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsSlice()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v1.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func rewriteValue_OpSlicePtr(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (SlicePtr (SliceMake ptr _ _ ))
	// result: ptr
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		ptr := v_0.Args[0]
		v.CopyOf(ptr)
		return true
	}
	// match: (SlicePtr x:(Load <t> ptr mem))
	// cond: t.IsSlice()
	// result: @x.Block (Load <t.Elem().PtrTo()> ptr mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsSlice()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, t.Elem().PtrTo())
		v.CopyOf(v0)
		v0.AddArg2(ptr, mem)
		return true
	}
	return false
}
func rewriteValue_OpSlicePtrUnchecked(v *ssa.Value) bool {
	v_0 := v.Args[0]
	// match: (SlicePtrUnchecked (SliceMake ptr _ _ ))
	// result: ptr
	for {
		if v_0.Op != ssaop.OpSliceMake {
			break
		}
		ptr := v_0.Args[0]
		v.CopyOf(ptr)
		return true
	}
	return false
}
func rewriteValue_OpStore(v *ssa.Value) bool {
	v_2 := v.Args[2]
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (Store {t} _ _ mem)
	// cond: t.Size() == 0
	// result: mem
	for {
		t := ssa.AuxToType(v.Aux)
		mem := v_2
		if !(t.Size() == 0) {
			break
		}
		v.CopyOf(mem)
		return true
	}
	// match: (Store {t} dst (ComplexMake real imag) mem)
	// cond: t.Size() == 8
	// result: (Store {typ.Float32} (OffPtr <typ.Float32Ptr> [4] dst) imag (Store {typ.Float32} dst real mem))
	for {
		t := ssa.AuxToType(v.Aux)
		dst := v_0
		if v_1.Op != ssaop.OpComplexMake {
			break
		}
		imag := v_1.Args[1]
		real := v_1.Args[0]
		mem := v_2
		if !(t.Size() == 8) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(typ.Float32)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Float32Ptr)
		v0.AuxInt = ssa.Int64ToAuxInt(4)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(typ.Float32)
		v1.AddArg3(dst, real, mem)
		v.AddArg3(v0, imag, v1)
		return true
	}
	// match: (Store {t} dst (ComplexMake real imag) mem)
	// cond: t.Size() == 16
	// result: (Store {typ.Float64} (OffPtr <typ.Float64Ptr> [8] dst) imag (Store {typ.Float64} dst real mem))
	for {
		t := ssa.AuxToType(v.Aux)
		dst := v_0
		if v_1.Op != ssaop.OpComplexMake {
			break
		}
		imag := v_1.Args[1]
		real := v_1.Args[0]
		mem := v_2
		if !(t.Size() == 16) {
			break
		}
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(typ.Float64)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.Float64Ptr)
		v0.AuxInt = ssa.Int64ToAuxInt(8)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(typ.Float64)
		v1.AddArg3(dst, real, mem)
		v.AddArg3(v0, imag, v1)
		return true
	}
	// match: (Store dst (StringMake ptr len) mem)
	// result: (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {typ.BytePtr} dst ptr mem))
	for {
		dst := v_0
		if v_1.Op != ssaop.OpStringMake {
			break
		}
		len := v_1.Args[1]
		ptr := v_1.Args[0]
		mem := v_2
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(typ.Int)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v0.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(typ.BytePtr)
		v1.AddArg3(dst, ptr, mem)
		v.AddArg3(v0, len, v1)
		return true
	}
	// match: (Store {t} dst (SliceMake ptr len cap) mem)
	// result: (Store {typ.Int} (OffPtr <typ.IntPtr> [2*config.PtrSize] dst) cap (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {t.Elem().PtrTo()} dst ptr mem)))
	for {
		t := ssa.AuxToType(v.Aux)
		dst := v_0
		if v_1.Op != ssaop.OpSliceMake {
			break
		}
		cap := v_1.Args[2]
		ptr := v_1.Args[0]
		len := v_1.Args[1]
		mem := v_2
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(typ.Int)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v0.AuxInt = ssa.Int64ToAuxInt(2 * config.PtrSize)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(typ.Int)
		v2 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v2.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v2.AddArg(dst)
		v3 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v3.Aux = ssa.TypeToAux(t.Elem().PtrTo())
		v3.AddArg3(dst, ptr, mem)
		v1.AddArg3(v2, len, v3)
		v.AddArg3(v0, cap, v1)
		return true
	}
	// match: (Store dst (IMake itab data) mem)
	// result: (Store {typ.BytePtr} (OffPtr <typ.BytePtrPtr> [config.PtrSize] dst) data (Store {typ.Uintptr} dst itab mem))
	for {
		dst := v_0
		if v_1.Op != ssaop.OpIMake {
			break
		}
		data := v_1.Args[1]
		itab := v_1.Args[0]
		mem := v_2
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(typ.BytePtr)
		v0 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.BytePtrPtr)
		v0.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v0.AddArg(dst)
		v1 := b.NewValue0(v.Pos, ssaop.OpStore, types.TypeMem)
		v1.Aux = ssa.TypeToAux(typ.Uintptr)
		v1.AddArg3(dst, itab, mem)
		v.AddArg3(v0, data, v1)
		return true
	}
	// match: (Store _ (StructMake ___) _)
	// result: ssa.RewriteStructStore(v)
	for {
		if v_1.Op != ssaop.OpStructMake {
			break
		}
		v.CopyOf(ssa.RewriteStructStore(v))
		return true
	}
	// match: (Store dst (ArrayMake1 e) mem)
	// result: (Store {e.Type} dst e mem)
	for {
		dst := v_0
		if v_1.Op != ssaop.OpArrayMake1 {
			break
		}
		e := v_1.Args[0]
		mem := v_2
		v.Reset(ssaop.OpStore)
		v.Aux = ssa.TypeToAux(e.Type)
		v.AddArg3(dst, e, mem)
		return true
	}
	return false
}
func rewriteValue_OpStringLen(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	config := b.Func.Config
	typ := &b.Func.Config.Types
	// match: (StringLen (StringMake _ len))
	// result: len
	for {
		if v_0.Op != ssaop.OpStringMake {
			break
		}
		len := v_0.Args[1]
		v.CopyOf(len)
		return true
	}
	// match: (StringLen x:(Load <t> ptr mem))
	// cond: t.IsString()
	// result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsString()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.Int)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, typ.IntPtr)
		v1.AuxInt = ssa.Int64ToAuxInt(config.PtrSize)
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func rewriteValue_OpStringPtr(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (StringPtr (StringMake ptr _))
	// result: ptr
	for {
		if v_0.Op != ssaop.OpStringMake {
			break
		}
		ptr := v_0.Args[0]
		v.CopyOf(ptr)
		return true
	}
	// match: (StringPtr x:(Load <t> ptr mem))
	// cond: t.IsString()
	// result: @x.Block (Load <typ.BytePtr> ptr mem)
	for {
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		if !(t.IsString()) {
			break
		}
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, typ.BytePtr)
		v.CopyOf(v0)
		v0.AddArg2(ptr, mem)
		return true
	}
	return false
}
func rewriteValue_OpStructMake(v *ssa.Value) bool {
	// match: (StructMake x)
	// cond: x.Type.IsPtrShaped()
	// result: x
	for {
		if len(v.Args) != 1 {
			break
		}
		x := v.Args[0]
		if !(x.Type.IsPtrShaped()) {
			break
		}
		v.CopyOf(x)
		return true
	}
	return false
}
func rewriteValue_OpStructSelect(v *ssa.Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	// match: (StructSelect (IData x))
	// cond: v.Type.Size() > 0
	// result: (IData x)
	for {
		if v_0.Op != ssaop.OpIData {
			break
		}
		x := v_0.Args[0]
		if !(v.Type.Size() > 0) {
			break
		}
		v.Reset(ssaop.OpIData)
		v.AddArg(x)
		return true
	}
	// match: (StructSelect (IData x))
	// cond: v.Type.Size() == 0
	// result: (Empty)
	for {
		if v_0.Op != ssaop.OpIData {
			break
		}
		if !(v.Type.Size() == 0) {
			break
		}
		v.Reset(ssaop.OpEmpty)
		return true
	}
	// match: (StructSelect [i] x:(StructMake ___))
	// result: x.Args[i]
	for {
		i := ssa.AuxIntToInt64(v.AuxInt)
		x := v_0
		if x.Op != ssaop.OpStructMake {
			break
		}
		v.CopyOf(x.Args[i])
		return true
	}
	// match: (StructSelect x)
	// cond: x.Type.IsPtrShaped()
	// result: x
	for {
		x := v_0
		if !(x.Type.IsPtrShaped()) {
			break
		}
		v.CopyOf(x)
		return true
	}
	// match: (StructSelect [i] x:(Load <t> ptr mem))
	// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
	for {
		i := ssa.AuxIntToInt64(v.AuxInt)
		x := v_0
		if x.Op != ssaop.OpLoad {
			break
		}
		t := x.Type
		mem := x.Args[1]
		ptr := x.Args[0]
		b = x.Block
		v0 := b.NewValue0(v.Pos, ssaop.OpLoad, v.Type)
		v.CopyOf(v0)
		v1 := b.NewValue0(v.Pos, ssaop.OpOffPtr, v.Type.PtrTo())
		v1.AuxInt = ssa.Int64ToAuxInt(t.FieldOff(int(i)))
		v1.AddArg(ptr)
		v0.AddArg2(v1, mem)
		return true
	}
	return false
}
func RewriteBlock(b *ssa.Block) bool {
	return false
}