1// Code generated from gen/dec.rules; DO NOT EDIT.
2// generated with: cd gen; go run *.go
3
4package ssa
5
6import "cmd/compile/internal/types"
7
8func rewriteValuedec(v *Value) bool {
9	switch v.Op {
10	case OpComplexImag:
11		return rewriteValuedec_OpComplexImag_0(v)
12	case OpComplexReal:
13		return rewriteValuedec_OpComplexReal_0(v)
14	case OpIData:
15		return rewriteValuedec_OpIData_0(v)
16	case OpITab:
17		return rewriteValuedec_OpITab_0(v)
18	case OpLoad:
19		return rewriteValuedec_OpLoad_0(v)
20	case OpSliceCap:
21		return rewriteValuedec_OpSliceCap_0(v)
22	case OpSliceLen:
23		return rewriteValuedec_OpSliceLen_0(v)
24	case OpSlicePtr:
25		return rewriteValuedec_OpSlicePtr_0(v)
26	case OpStore:
27		return rewriteValuedec_OpStore_0(v)
28	case OpStringLen:
29		return rewriteValuedec_OpStringLen_0(v)
30	case OpStringPtr:
31		return rewriteValuedec_OpStringPtr_0(v)
32	}
33	return false
34}
35func rewriteValuedec_OpComplexImag_0(v *Value) bool {
36	// match: (ComplexImag (ComplexMake _ imag))
37	// result: imag
38	for {
39		v_0 := v.Args[0]
40		if v_0.Op != OpComplexMake {
41			break
42		}
43		imag := v_0.Args[1]
44		v.reset(OpCopy)
45		v.Type = imag.Type
46		v.AddArg(imag)
47		return true
48	}
49	return false
50}
51func rewriteValuedec_OpComplexReal_0(v *Value) bool {
52	// match: (ComplexReal (ComplexMake real _))
53	// result: real
54	for {
55		v_0 := v.Args[0]
56		if v_0.Op != OpComplexMake {
57			break
58		}
59		_ = v_0.Args[1]
60		real := v_0.Args[0]
61		v.reset(OpCopy)
62		v.Type = real.Type
63		v.AddArg(real)
64		return true
65	}
66	return false
67}
68func rewriteValuedec_OpIData_0(v *Value) bool {
69	// match: (IData (IMake _ data))
70	// result: data
71	for {
72		v_0 := v.Args[0]
73		if v_0.Op != OpIMake {
74			break
75		}
76		data := v_0.Args[1]
77		v.reset(OpCopy)
78		v.Type = data.Type
79		v.AddArg(data)
80		return true
81	}
82	return false
83}
84func rewriteValuedec_OpITab_0(v *Value) bool {
85	// match: (ITab (IMake itab _))
86	// result: itab
87	for {
88		v_0 := v.Args[0]
89		if v_0.Op != OpIMake {
90			break
91		}
92		_ = v_0.Args[1]
93		itab := v_0.Args[0]
94		v.reset(OpCopy)
95		v.Type = itab.Type
96		v.AddArg(itab)
97		return true
98	}
99	return false
100}
101func rewriteValuedec_OpLoad_0(v *Value) bool {
102	b := v.Block
103	config := b.Func.Config
104	typ := &b.Func.Config.Types
105	// match: (Load <t> ptr mem)
106	// cond: t.IsComplex() && t.Size() == 8
107	// result: (ComplexMake (Load <typ.Float32> ptr mem) (Load <typ.Float32> (OffPtr <typ.Float32Ptr> [4] ptr) mem) )
108	for {
109		t := v.Type
110		mem := v.Args[1]
111		ptr := v.Args[0]
112		if !(t.IsComplex() && t.Size() == 8) {
113			break
114		}
115		v.reset(OpComplexMake)
116		v0 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
117		v0.AddArg(ptr)
118		v0.AddArg(mem)
119		v.AddArg(v0)
120		v1 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
121		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
122		v2.AuxInt = 4
123		v2.AddArg(ptr)
124		v1.AddArg(v2)
125		v1.AddArg(mem)
126		v.AddArg(v1)
127		return true
128	}
129	// match: (Load <t> ptr mem)
130	// cond: t.IsComplex() && t.Size() == 16
131	// result: (ComplexMake (Load <typ.Float64> ptr mem) (Load <typ.Float64> (OffPtr <typ.Float64Ptr> [8] ptr) mem) )
132	for {
133		t := v.Type
134		mem := v.Args[1]
135		ptr := v.Args[0]
136		if !(t.IsComplex() && t.Size() == 16) {
137			break
138		}
139		v.reset(OpComplexMake)
140		v0 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
141		v0.AddArg(ptr)
142		v0.AddArg(mem)
143		v.AddArg(v0)
144		v1 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
145		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
146		v2.AuxInt = 8
147		v2.AddArg(ptr)
148		v1.AddArg(v2)
149		v1.AddArg(mem)
150		v.AddArg(v1)
151		return true
152	}
153	// match: (Load <t> ptr mem)
154	// cond: t.IsString()
155	// result: (StringMake (Load <typ.BytePtr> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem))
156	for {
157		t := v.Type
158		mem := v.Args[1]
159		ptr := v.Args[0]
160		if !(t.IsString()) {
161			break
162		}
163		v.reset(OpStringMake)
164		v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
165		v0.AddArg(ptr)
166		v0.AddArg(mem)
167		v.AddArg(v0)
168		v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
169		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
170		v2.AuxInt = config.PtrSize
171		v2.AddArg(ptr)
172		v1.AddArg(v2)
173		v1.AddArg(mem)
174		v.AddArg(v1)
175		return true
176	}
177	// match: (Load <t> ptr mem)
178	// cond: t.IsSlice()
179	// 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))
180	for {
181		t := v.Type
182		mem := v.Args[1]
183		ptr := v.Args[0]
184		if !(t.IsSlice()) {
185			break
186		}
187		v.reset(OpSliceMake)
188		v0 := b.NewValue0(v.Pos, OpLoad, t.Elem().PtrTo())
189		v0.AddArg(ptr)
190		v0.AddArg(mem)
191		v.AddArg(v0)
192		v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
193		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
194		v2.AuxInt = config.PtrSize
195		v2.AddArg(ptr)
196		v1.AddArg(v2)
197		v1.AddArg(mem)
198		v.AddArg(v1)
199		v3 := b.NewValue0(v.Pos, OpLoad, typ.Int)
200		v4 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
201		v4.AuxInt = 2 * config.PtrSize
202		v4.AddArg(ptr)
203		v3.AddArg(v4)
204		v3.AddArg(mem)
205		v.AddArg(v3)
206		return true
207	}
208	// match: (Load <t> ptr mem)
209	// cond: t.IsInterface()
210	// result: (IMake (Load <typ.Uintptr> ptr mem) (Load <typ.BytePtr> (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr) mem))
211	for {
212		t := v.Type
213		mem := v.Args[1]
214		ptr := v.Args[0]
215		if !(t.IsInterface()) {
216			break
217		}
218		v.reset(OpIMake)
219		v0 := b.NewValue0(v.Pos, OpLoad, typ.Uintptr)
220		v0.AddArg(ptr)
221		v0.AddArg(mem)
222		v.AddArg(v0)
223		v1 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
224		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
225		v2.AuxInt = config.PtrSize
226		v2.AddArg(ptr)
227		v1.AddArg(v2)
228		v1.AddArg(mem)
229		v.AddArg(v1)
230		return true
231	}
232	return false
233}
234func rewriteValuedec_OpSliceCap_0(v *Value) bool {
235	// match: (SliceCap (SliceMake _ _ cap))
236	// result: cap
237	for {
238		v_0 := v.Args[0]
239		if v_0.Op != OpSliceMake {
240			break
241		}
242		cap := v_0.Args[2]
243		v.reset(OpCopy)
244		v.Type = cap.Type
245		v.AddArg(cap)
246		return true
247	}
248	return false
249}
250func rewriteValuedec_OpSliceLen_0(v *Value) bool {
251	// match: (SliceLen (SliceMake _ len _))
252	// result: len
253	for {
254		v_0 := v.Args[0]
255		if v_0.Op != OpSliceMake {
256			break
257		}
258		_ = v_0.Args[2]
259		len := v_0.Args[1]
260		v.reset(OpCopy)
261		v.Type = len.Type
262		v.AddArg(len)
263		return true
264	}
265	return false
266}
267func rewriteValuedec_OpSlicePtr_0(v *Value) bool {
268	// match: (SlicePtr (SliceMake ptr _ _))
269	// result: ptr
270	for {
271		v_0 := v.Args[0]
272		if v_0.Op != OpSliceMake {
273			break
274		}
275		_ = v_0.Args[2]
276		ptr := v_0.Args[0]
277		v.reset(OpCopy)
278		v.Type = ptr.Type
279		v.AddArg(ptr)
280		return true
281	}
282	return false
283}
284func rewriteValuedec_OpStore_0(v *Value) bool {
285	b := v.Block
286	config := b.Func.Config
287	typ := &b.Func.Config.Types
288	// match: (Store {t} dst (ComplexMake real imag) mem)
289	// cond: t.(*types.Type).Size() == 8
290	// result: (Store {typ.Float32} (OffPtr <typ.Float32Ptr> [4] dst) imag (Store {typ.Float32} dst real mem))
291	for {
292		t := v.Aux
293		mem := v.Args[2]
294		dst := v.Args[0]
295		v_1 := v.Args[1]
296		if v_1.Op != OpComplexMake {
297			break
298		}
299		imag := v_1.Args[1]
300		real := v_1.Args[0]
301		if !(t.(*types.Type).Size() == 8) {
302			break
303		}
304		v.reset(OpStore)
305		v.Aux = typ.Float32
306		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
307		v0.AuxInt = 4
308		v0.AddArg(dst)
309		v.AddArg(v0)
310		v.AddArg(imag)
311		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
312		v1.Aux = typ.Float32
313		v1.AddArg(dst)
314		v1.AddArg(real)
315		v1.AddArg(mem)
316		v.AddArg(v1)
317		return true
318	}
319	// match: (Store {t} dst (ComplexMake real imag) mem)
320	// cond: t.(*types.Type).Size() == 16
321	// result: (Store {typ.Float64} (OffPtr <typ.Float64Ptr> [8] dst) imag (Store {typ.Float64} dst real mem))
322	for {
323		t := v.Aux
324		mem := v.Args[2]
325		dst := v.Args[0]
326		v_1 := v.Args[1]
327		if v_1.Op != OpComplexMake {
328			break
329		}
330		imag := v_1.Args[1]
331		real := v_1.Args[0]
332		if !(t.(*types.Type).Size() == 16) {
333			break
334		}
335		v.reset(OpStore)
336		v.Aux = typ.Float64
337		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
338		v0.AuxInt = 8
339		v0.AddArg(dst)
340		v.AddArg(v0)
341		v.AddArg(imag)
342		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
343		v1.Aux = typ.Float64
344		v1.AddArg(dst)
345		v1.AddArg(real)
346		v1.AddArg(mem)
347		v.AddArg(v1)
348		return true
349	}
350	// match: (Store dst (StringMake ptr len) mem)
351	// result: (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {typ.BytePtr} dst ptr mem))
352	for {
353		mem := v.Args[2]
354		dst := v.Args[0]
355		v_1 := v.Args[1]
356		if v_1.Op != OpStringMake {
357			break
358		}
359		len := v_1.Args[1]
360		ptr := v_1.Args[0]
361		v.reset(OpStore)
362		v.Aux = typ.Int
363		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
364		v0.AuxInt = config.PtrSize
365		v0.AddArg(dst)
366		v.AddArg(v0)
367		v.AddArg(len)
368		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
369		v1.Aux = typ.BytePtr
370		v1.AddArg(dst)
371		v1.AddArg(ptr)
372		v1.AddArg(mem)
373		v.AddArg(v1)
374		return true
375	}
376	// match: (Store dst (SliceMake ptr len cap) mem)
377	// result: (Store {typ.Int} (OffPtr <typ.IntPtr> [2*config.PtrSize] dst) cap (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {typ.BytePtr} dst ptr mem)))
378	for {
379		mem := v.Args[2]
380		dst := v.Args[0]
381		v_1 := v.Args[1]
382		if v_1.Op != OpSliceMake {
383			break
384		}
385		cap := v_1.Args[2]
386		ptr := v_1.Args[0]
387		len := v_1.Args[1]
388		v.reset(OpStore)
389		v.Aux = typ.Int
390		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
391		v0.AuxInt = 2 * config.PtrSize
392		v0.AddArg(dst)
393		v.AddArg(v0)
394		v.AddArg(cap)
395		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
396		v1.Aux = typ.Int
397		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
398		v2.AuxInt = config.PtrSize
399		v2.AddArg(dst)
400		v1.AddArg(v2)
401		v1.AddArg(len)
402		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
403		v3.Aux = typ.BytePtr
404		v3.AddArg(dst)
405		v3.AddArg(ptr)
406		v3.AddArg(mem)
407		v1.AddArg(v3)
408		v.AddArg(v1)
409		return true
410	}
411	// match: (Store dst (IMake itab data) mem)
412	// result: (Store {typ.BytePtr} (OffPtr <typ.BytePtrPtr> [config.PtrSize] dst) data (Store {typ.Uintptr} dst itab mem))
413	for {
414		mem := v.Args[2]
415		dst := v.Args[0]
416		v_1 := v.Args[1]
417		if v_1.Op != OpIMake {
418			break
419		}
420		data := v_1.Args[1]
421		itab := v_1.Args[0]
422		v.reset(OpStore)
423		v.Aux = typ.BytePtr
424		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
425		v0.AuxInt = config.PtrSize
426		v0.AddArg(dst)
427		v.AddArg(v0)
428		v.AddArg(data)
429		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
430		v1.Aux = typ.Uintptr
431		v1.AddArg(dst)
432		v1.AddArg(itab)
433		v1.AddArg(mem)
434		v.AddArg(v1)
435		return true
436	}
437	return false
438}
439func rewriteValuedec_OpStringLen_0(v *Value) bool {
440	// match: (StringLen (StringMake _ len))
441	// result: len
442	for {
443		v_0 := v.Args[0]
444		if v_0.Op != OpStringMake {
445			break
446		}
447		len := v_0.Args[1]
448		v.reset(OpCopy)
449		v.Type = len.Type
450		v.AddArg(len)
451		return true
452	}
453	return false
454}
455func rewriteValuedec_OpStringPtr_0(v *Value) bool {
456	// match: (StringPtr (StringMake ptr _))
457	// result: ptr
458	for {
459		v_0 := v.Args[0]
460		if v_0.Op != OpStringMake {
461			break
462		}
463		_ = v_0.Args[1]
464		ptr := v_0.Args[0]
465		v.reset(OpCopy)
466		v.Type = ptr.Type
467		v.AddArg(ptr)
468		return true
469	}
470	return false
471}
472func rewriteBlockdec(b *Block) bool {
473	switch b.Kind {
474	}
475	return false
476}
477