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