1// Code generated from _gen/dec64.rules using 'go generate'; DO NOT EDIT. 2 3package ssa 4 5import "cmd/compile/internal/types" 6 7func rewriteValuedec64(v *Value) bool { 8 switch v.Op { 9 case OpAdd64: 10 return rewriteValuedec64_OpAdd64(v) 11 case OpAnd64: 12 return rewriteValuedec64_OpAnd64(v) 13 case OpArg: 14 return rewriteValuedec64_OpArg(v) 15 case OpBitLen64: 16 return rewriteValuedec64_OpBitLen64(v) 17 case OpBswap64: 18 return rewriteValuedec64_OpBswap64(v) 19 case OpCom64: 20 return rewriteValuedec64_OpCom64(v) 21 case OpConst64: 22 return rewriteValuedec64_OpConst64(v) 23 case OpCtz64: 24 return rewriteValuedec64_OpCtz64(v) 25 case OpCtz64NonZero: 26 v.Op = OpCtz64 27 return true 28 case OpEq64: 29 return rewriteValuedec64_OpEq64(v) 30 case OpInt64Hi: 31 return rewriteValuedec64_OpInt64Hi(v) 32 case OpInt64Lo: 33 return rewriteValuedec64_OpInt64Lo(v) 34 case OpLeq64: 35 return rewriteValuedec64_OpLeq64(v) 36 case OpLeq64U: 37 return rewriteValuedec64_OpLeq64U(v) 38 case OpLess64: 39 return rewriteValuedec64_OpLess64(v) 40 case OpLess64U: 41 return rewriteValuedec64_OpLess64U(v) 42 case OpLoad: 43 return rewriteValuedec64_OpLoad(v) 44 case OpLsh16x64: 45 return rewriteValuedec64_OpLsh16x64(v) 46 case OpLsh32x64: 47 return rewriteValuedec64_OpLsh32x64(v) 48 case OpLsh64x16: 49 return rewriteValuedec64_OpLsh64x16(v) 50 case OpLsh64x32: 51 return rewriteValuedec64_OpLsh64x32(v) 52 case OpLsh64x64: 53 return rewriteValuedec64_OpLsh64x64(v) 54 case OpLsh64x8: 55 return rewriteValuedec64_OpLsh64x8(v) 56 case OpLsh8x64: 57 return rewriteValuedec64_OpLsh8x64(v) 58 case OpMul64: 59 return rewriteValuedec64_OpMul64(v) 60 case OpNeg64: 61 return rewriteValuedec64_OpNeg64(v) 62 case OpNeq64: 63 return rewriteValuedec64_OpNeq64(v) 64 case OpOr32: 65 return rewriteValuedec64_OpOr32(v) 66 case OpOr64: 67 return rewriteValuedec64_OpOr64(v) 68 case OpRotateLeft16: 69 return rewriteValuedec64_OpRotateLeft16(v) 70 case OpRotateLeft32: 71 return rewriteValuedec64_OpRotateLeft32(v) 72 case OpRotateLeft64: 73 return rewriteValuedec64_OpRotateLeft64(v) 74 case OpRotateLeft8: 75 return rewriteValuedec64_OpRotateLeft8(v) 76 case OpRsh16Ux64: 77 return rewriteValuedec64_OpRsh16Ux64(v) 78 case OpRsh16x64: 79 return rewriteValuedec64_OpRsh16x64(v) 80 case OpRsh32Ux64: 81 return rewriteValuedec64_OpRsh32Ux64(v) 82 case OpRsh32x64: 83 return rewriteValuedec64_OpRsh32x64(v) 84 case OpRsh64Ux16: 85 return rewriteValuedec64_OpRsh64Ux16(v) 86 case OpRsh64Ux32: 87 return rewriteValuedec64_OpRsh64Ux32(v) 88 case OpRsh64Ux64: 89 return rewriteValuedec64_OpRsh64Ux64(v) 90 case OpRsh64Ux8: 91 return rewriteValuedec64_OpRsh64Ux8(v) 92 case OpRsh64x16: 93 return rewriteValuedec64_OpRsh64x16(v) 94 case OpRsh64x32: 95 return rewriteValuedec64_OpRsh64x32(v) 96 case OpRsh64x64: 97 return rewriteValuedec64_OpRsh64x64(v) 98 case OpRsh64x8: 99 return rewriteValuedec64_OpRsh64x8(v) 100 case OpRsh8Ux64: 101 return rewriteValuedec64_OpRsh8Ux64(v) 102 case OpRsh8x64: 103 return rewriteValuedec64_OpRsh8x64(v) 104 case OpSignExt16to64: 105 return rewriteValuedec64_OpSignExt16to64(v) 106 case OpSignExt32to64: 107 return rewriteValuedec64_OpSignExt32to64(v) 108 case OpSignExt8to64: 109 return rewriteValuedec64_OpSignExt8to64(v) 110 case OpStore: 111 return rewriteValuedec64_OpStore(v) 112 case OpSub64: 113 return rewriteValuedec64_OpSub64(v) 114 case OpTrunc64to16: 115 return rewriteValuedec64_OpTrunc64to16(v) 116 case OpTrunc64to32: 117 return rewriteValuedec64_OpTrunc64to32(v) 118 case OpTrunc64to8: 119 return rewriteValuedec64_OpTrunc64to8(v) 120 case OpXor64: 121 return rewriteValuedec64_OpXor64(v) 122 case OpZeroExt16to64: 123 return rewriteValuedec64_OpZeroExt16to64(v) 124 case OpZeroExt32to64: 125 return rewriteValuedec64_OpZeroExt32to64(v) 126 case OpZeroExt8to64: 127 return rewriteValuedec64_OpZeroExt8to64(v) 128 } 129 return false 130} 131func rewriteValuedec64_OpAdd64(v *Value) bool { 132 v_1 := v.Args[1] 133 v_0 := v.Args[0] 134 b := v.Block 135 typ := &b.Func.Config.Types 136 // match: (Add64 x y) 137 // result: (Int64Make (Add32withcarry <typ.Int32> (Int64Hi x) (Int64Hi y) (Select1 <types.TypeFlags> (Add32carry (Int64Lo x) (Int64Lo y)))) (Select0 <typ.UInt32> (Add32carry (Int64Lo x) (Int64Lo y)))) 138 for { 139 x := v_0 140 y := v_1 141 v.reset(OpInt64Make) 142 v0 := b.NewValue0(v.Pos, OpAdd32withcarry, typ.Int32) 143 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 144 v1.AddArg(x) 145 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 146 v2.AddArg(y) 147 v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags) 148 v4 := b.NewValue0(v.Pos, OpAdd32carry, types.NewTuple(typ.UInt32, types.TypeFlags)) 149 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 150 v5.AddArg(x) 151 v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 152 v6.AddArg(y) 153 v4.AddArg2(v5, v6) 154 v3.AddArg(v4) 155 v0.AddArg3(v1, v2, v3) 156 v7 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32) 157 v7.AddArg(v4) 158 v.AddArg2(v0, v7) 159 return true 160 } 161} 162func rewriteValuedec64_OpAnd64(v *Value) bool { 163 v_1 := v.Args[1] 164 v_0 := v.Args[0] 165 b := v.Block 166 typ := &b.Func.Config.Types 167 // match: (And64 x y) 168 // result: (Int64Make (And32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (And32 <typ.UInt32> (Int64Lo x) (Int64Lo y))) 169 for { 170 x := v_0 171 y := v_1 172 v.reset(OpInt64Make) 173 v0 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32) 174 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 175 v1.AddArg(x) 176 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 177 v2.AddArg(y) 178 v0.AddArg2(v1, v2) 179 v3 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32) 180 v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 181 v4.AddArg(x) 182 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 183 v5.AddArg(y) 184 v3.AddArg2(v4, v5) 185 v.AddArg2(v0, v3) 186 return true 187 } 188} 189func rewriteValuedec64_OpArg(v *Value) bool { 190 b := v.Block 191 config := b.Func.Config 192 typ := &b.Func.Config.Types 193 // match: (Arg {n} [off]) 194 // cond: is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") 195 // result: (Int64Make (Arg <typ.Int32> {n} [off+4]) (Arg <typ.UInt32> {n} [off])) 196 for { 197 off := auxIntToInt32(v.AuxInt) 198 n := auxToSym(v.Aux) 199 if !(is64BitInt(v.Type) && !config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) { 200 break 201 } 202 v.reset(OpInt64Make) 203 v0 := b.NewValue0(v.Pos, OpArg, typ.Int32) 204 v0.AuxInt = int32ToAuxInt(off + 4) 205 v0.Aux = symToAux(n) 206 v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32) 207 v1.AuxInt = int32ToAuxInt(off) 208 v1.Aux = symToAux(n) 209 v.AddArg2(v0, v1) 210 return true 211 } 212 // match: (Arg {n} [off]) 213 // cond: is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") 214 // result: (Int64Make (Arg <typ.UInt32> {n} [off+4]) (Arg <typ.UInt32> {n} [off])) 215 for { 216 off := auxIntToInt32(v.AuxInt) 217 n := auxToSym(v.Aux) 218 if !(is64BitInt(v.Type) && !config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) { 219 break 220 } 221 v.reset(OpInt64Make) 222 v0 := b.NewValue0(v.Pos, OpArg, typ.UInt32) 223 v0.AuxInt = int32ToAuxInt(off + 4) 224 v0.Aux = symToAux(n) 225 v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32) 226 v1.AuxInt = int32ToAuxInt(off) 227 v1.Aux = symToAux(n) 228 v.AddArg2(v0, v1) 229 return true 230 } 231 // match: (Arg {n} [off]) 232 // cond: is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") 233 // result: (Int64Make (Arg <typ.Int32> {n} [off]) (Arg <typ.UInt32> {n} [off+4])) 234 for { 235 off := auxIntToInt32(v.AuxInt) 236 n := auxToSym(v.Aux) 237 if !(is64BitInt(v.Type) && config.BigEndian && v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) { 238 break 239 } 240 v.reset(OpInt64Make) 241 v0 := b.NewValue0(v.Pos, OpArg, typ.Int32) 242 v0.AuxInt = int32ToAuxInt(off) 243 v0.Aux = symToAux(n) 244 v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32) 245 v1.AuxInt = int32ToAuxInt(off + 4) 246 v1.Aux = symToAux(n) 247 v.AddArg2(v0, v1) 248 return true 249 } 250 // match: (Arg {n} [off]) 251 // cond: is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin") 252 // result: (Int64Make (Arg <typ.UInt32> {n} [off]) (Arg <typ.UInt32> {n} [off+4])) 253 for { 254 off := auxIntToInt32(v.AuxInt) 255 n := auxToSym(v.Aux) 256 if !(is64BitInt(v.Type) && config.BigEndian && !v.Type.IsSigned() && !(b.Func.pass.name == "decompose builtin")) { 257 break 258 } 259 v.reset(OpInt64Make) 260 v0 := b.NewValue0(v.Pos, OpArg, typ.UInt32) 261 v0.AuxInt = int32ToAuxInt(off) 262 v0.Aux = symToAux(n) 263 v1 := b.NewValue0(v.Pos, OpArg, typ.UInt32) 264 v1.AuxInt = int32ToAuxInt(off + 4) 265 v1.Aux = symToAux(n) 266 v.AddArg2(v0, v1) 267 return true 268 } 269 return false 270} 271func rewriteValuedec64_OpBitLen64(v *Value) bool { 272 v_0 := v.Args[0] 273 b := v.Block 274 typ := &b.Func.Config.Types 275 // match: (BitLen64 x) 276 // result: (Add32 <typ.Int> (BitLen32 <typ.Int> (Int64Hi x)) (BitLen32 <typ.Int> (Or32 <typ.UInt32> (Int64Lo x) (Zeromask (Int64Hi x))))) 277 for { 278 x := v_0 279 v.reset(OpAdd32) 280 v.Type = typ.Int 281 v0 := b.NewValue0(v.Pos, OpBitLen32, typ.Int) 282 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 283 v1.AddArg(x) 284 v0.AddArg(v1) 285 v2 := b.NewValue0(v.Pos, OpBitLen32, typ.Int) 286 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 287 v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 288 v4.AddArg(x) 289 v5 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 290 v5.AddArg(v1) 291 v3.AddArg2(v4, v5) 292 v2.AddArg(v3) 293 v.AddArg2(v0, v2) 294 return true 295 } 296} 297func rewriteValuedec64_OpBswap64(v *Value) bool { 298 v_0 := v.Args[0] 299 b := v.Block 300 typ := &b.Func.Config.Types 301 // match: (Bswap64 x) 302 // result: (Int64Make (Bswap32 <typ.UInt32> (Int64Lo x)) (Bswap32 <typ.UInt32> (Int64Hi x))) 303 for { 304 x := v_0 305 v.reset(OpInt64Make) 306 v0 := b.NewValue0(v.Pos, OpBswap32, typ.UInt32) 307 v1 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 308 v1.AddArg(x) 309 v0.AddArg(v1) 310 v2 := b.NewValue0(v.Pos, OpBswap32, typ.UInt32) 311 v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 312 v3.AddArg(x) 313 v2.AddArg(v3) 314 v.AddArg2(v0, v2) 315 return true 316 } 317} 318func rewriteValuedec64_OpCom64(v *Value) bool { 319 v_0 := v.Args[0] 320 b := v.Block 321 typ := &b.Func.Config.Types 322 // match: (Com64 x) 323 // result: (Int64Make (Com32 <typ.UInt32> (Int64Hi x)) (Com32 <typ.UInt32> (Int64Lo x))) 324 for { 325 x := v_0 326 v.reset(OpInt64Make) 327 v0 := b.NewValue0(v.Pos, OpCom32, typ.UInt32) 328 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 329 v1.AddArg(x) 330 v0.AddArg(v1) 331 v2 := b.NewValue0(v.Pos, OpCom32, typ.UInt32) 332 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 333 v3.AddArg(x) 334 v2.AddArg(v3) 335 v.AddArg2(v0, v2) 336 return true 337 } 338} 339func rewriteValuedec64_OpConst64(v *Value) bool { 340 b := v.Block 341 typ := &b.Func.Config.Types 342 // match: (Const64 <t> [c]) 343 // cond: t.IsSigned() 344 // result: (Int64Make (Const32 <typ.Int32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)])) 345 for { 346 t := v.Type 347 c := auxIntToInt64(v.AuxInt) 348 if !(t.IsSigned()) { 349 break 350 } 351 v.reset(OpInt64Make) 352 v0 := b.NewValue0(v.Pos, OpConst32, typ.Int32) 353 v0.AuxInt = int32ToAuxInt(int32(c >> 32)) 354 v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 355 v1.AuxInt = int32ToAuxInt(int32(c)) 356 v.AddArg2(v0, v1) 357 return true 358 } 359 // match: (Const64 <t> [c]) 360 // cond: !t.IsSigned() 361 // result: (Int64Make (Const32 <typ.UInt32> [int32(c>>32)]) (Const32 <typ.UInt32> [int32(c)])) 362 for { 363 t := v.Type 364 c := auxIntToInt64(v.AuxInt) 365 if !(!t.IsSigned()) { 366 break 367 } 368 v.reset(OpInt64Make) 369 v0 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 370 v0.AuxInt = int32ToAuxInt(int32(c >> 32)) 371 v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 372 v1.AuxInt = int32ToAuxInt(int32(c)) 373 v.AddArg2(v0, v1) 374 return true 375 } 376 return false 377} 378func rewriteValuedec64_OpCtz64(v *Value) bool { 379 v_0 := v.Args[0] 380 b := v.Block 381 typ := &b.Func.Config.Types 382 // match: (Ctz64 x) 383 // result: (Add32 <typ.UInt32> (Ctz32 <typ.UInt32> (Int64Lo x)) (And32 <typ.UInt32> (Com32 <typ.UInt32> (Zeromask (Int64Lo x))) (Ctz32 <typ.UInt32> (Int64Hi x)))) 384 for { 385 x := v_0 386 v.reset(OpAdd32) 387 v.Type = typ.UInt32 388 v0 := b.NewValue0(v.Pos, OpCtz32, typ.UInt32) 389 v1 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 390 v1.AddArg(x) 391 v0.AddArg(v1) 392 v2 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32) 393 v3 := b.NewValue0(v.Pos, OpCom32, typ.UInt32) 394 v4 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 395 v4.AddArg(v1) 396 v3.AddArg(v4) 397 v5 := b.NewValue0(v.Pos, OpCtz32, typ.UInt32) 398 v6 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 399 v6.AddArg(x) 400 v5.AddArg(v6) 401 v2.AddArg2(v3, v5) 402 v.AddArg2(v0, v2) 403 return true 404 } 405} 406func rewriteValuedec64_OpEq64(v *Value) bool { 407 v_1 := v.Args[1] 408 v_0 := v.Args[0] 409 b := v.Block 410 typ := &b.Func.Config.Types 411 // match: (Eq64 x y) 412 // result: (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Eq32 (Int64Lo x) (Int64Lo y))) 413 for { 414 x := v_0 415 y := v_1 416 v.reset(OpAndB) 417 v0 := b.NewValue0(v.Pos, OpEq32, typ.Bool) 418 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 419 v1.AddArg(x) 420 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 421 v2.AddArg(y) 422 v0.AddArg2(v1, v2) 423 v3 := b.NewValue0(v.Pos, OpEq32, typ.Bool) 424 v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 425 v4.AddArg(x) 426 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 427 v5.AddArg(y) 428 v3.AddArg2(v4, v5) 429 v.AddArg2(v0, v3) 430 return true 431 } 432} 433func rewriteValuedec64_OpInt64Hi(v *Value) bool { 434 v_0 := v.Args[0] 435 // match: (Int64Hi (Int64Make hi _)) 436 // result: hi 437 for { 438 if v_0.Op != OpInt64Make { 439 break 440 } 441 hi := v_0.Args[0] 442 v.copyOf(hi) 443 return true 444 } 445 return false 446} 447func rewriteValuedec64_OpInt64Lo(v *Value) bool { 448 v_0 := v.Args[0] 449 // match: (Int64Lo (Int64Make _ lo)) 450 // result: lo 451 for { 452 if v_0.Op != OpInt64Make { 453 break 454 } 455 lo := v_0.Args[1] 456 v.copyOf(lo) 457 return true 458 } 459 return false 460} 461func rewriteValuedec64_OpLeq64(v *Value) bool { 462 v_1 := v.Args[1] 463 v_0 := v.Args[0] 464 b := v.Block 465 typ := &b.Func.Config.Types 466 // match: (Leq64 x y) 467 // result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y)))) 468 for { 469 x := v_0 470 y := v_1 471 v.reset(OpOrB) 472 v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool) 473 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 474 v1.AddArg(x) 475 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 476 v2.AddArg(y) 477 v0.AddArg2(v1, v2) 478 v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool) 479 v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool) 480 v4.AddArg2(v1, v2) 481 v5 := b.NewValue0(v.Pos, OpLeq32U, typ.Bool) 482 v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 483 v6.AddArg(x) 484 v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 485 v7.AddArg(y) 486 v5.AddArg2(v6, v7) 487 v3.AddArg2(v4, v5) 488 v.AddArg2(v0, v3) 489 return true 490 } 491} 492func rewriteValuedec64_OpLeq64U(v *Value) bool { 493 v_1 := v.Args[1] 494 v_0 := v.Args[0] 495 b := v.Block 496 typ := &b.Func.Config.Types 497 // match: (Leq64U x y) 498 // result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Leq32U (Int64Lo x) (Int64Lo y)))) 499 for { 500 x := v_0 501 y := v_1 502 v.reset(OpOrB) 503 v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool) 504 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 505 v1.AddArg(x) 506 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 507 v2.AddArg(y) 508 v0.AddArg2(v1, v2) 509 v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool) 510 v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool) 511 v4.AddArg2(v1, v2) 512 v5 := b.NewValue0(v.Pos, OpLeq32U, typ.Bool) 513 v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 514 v6.AddArg(x) 515 v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 516 v7.AddArg(y) 517 v5.AddArg2(v6, v7) 518 v3.AddArg2(v4, v5) 519 v.AddArg2(v0, v3) 520 return true 521 } 522} 523func rewriteValuedec64_OpLess64(v *Value) bool { 524 v_1 := v.Args[1] 525 v_0 := v.Args[0] 526 b := v.Block 527 typ := &b.Func.Config.Types 528 // match: (Less64 x y) 529 // result: (OrB (Less32 (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y)))) 530 for { 531 x := v_0 532 y := v_1 533 v.reset(OpOrB) 534 v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool) 535 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 536 v1.AddArg(x) 537 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 538 v2.AddArg(y) 539 v0.AddArg2(v1, v2) 540 v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool) 541 v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool) 542 v4.AddArg2(v1, v2) 543 v5 := b.NewValue0(v.Pos, OpLess32U, typ.Bool) 544 v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 545 v6.AddArg(x) 546 v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 547 v7.AddArg(y) 548 v5.AddArg2(v6, v7) 549 v3.AddArg2(v4, v5) 550 v.AddArg2(v0, v3) 551 return true 552 } 553} 554func rewriteValuedec64_OpLess64U(v *Value) bool { 555 v_1 := v.Args[1] 556 v_0 := v.Args[0] 557 b := v.Block 558 typ := &b.Func.Config.Types 559 // match: (Less64U x y) 560 // result: (OrB (Less32U (Int64Hi x) (Int64Hi y)) (AndB (Eq32 (Int64Hi x) (Int64Hi y)) (Less32U (Int64Lo x) (Int64Lo y)))) 561 for { 562 x := v_0 563 y := v_1 564 v.reset(OpOrB) 565 v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool) 566 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 567 v1.AddArg(x) 568 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 569 v2.AddArg(y) 570 v0.AddArg2(v1, v2) 571 v3 := b.NewValue0(v.Pos, OpAndB, typ.Bool) 572 v4 := b.NewValue0(v.Pos, OpEq32, typ.Bool) 573 v4.AddArg2(v1, v2) 574 v5 := b.NewValue0(v.Pos, OpLess32U, typ.Bool) 575 v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 576 v6.AddArg(x) 577 v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 578 v7.AddArg(y) 579 v5.AddArg2(v6, v7) 580 v3.AddArg2(v4, v5) 581 v.AddArg2(v0, v3) 582 return true 583 } 584} 585func rewriteValuedec64_OpLoad(v *Value) bool { 586 v_1 := v.Args[1] 587 v_0 := v.Args[0] 588 b := v.Block 589 config := b.Func.Config 590 typ := &b.Func.Config.Types 591 // match: (Load <t> ptr mem) 592 // cond: is64BitInt(t) && !config.BigEndian && t.IsSigned() 593 // result: (Int64Make (Load <typ.Int32> (OffPtr <typ.Int32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem)) 594 for { 595 t := v.Type 596 ptr := v_0 597 mem := v_1 598 if !(is64BitInt(t) && !config.BigEndian && t.IsSigned()) { 599 break 600 } 601 v.reset(OpInt64Make) 602 v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32) 603 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.Int32Ptr) 604 v1.AuxInt = int64ToAuxInt(4) 605 v1.AddArg(ptr) 606 v0.AddArg2(v1, mem) 607 v2 := b.NewValue0(v.Pos, OpLoad, typ.UInt32) 608 v2.AddArg2(ptr, mem) 609 v.AddArg2(v0, v2) 610 return true 611 } 612 // match: (Load <t> ptr mem) 613 // cond: is64BitInt(t) && !config.BigEndian && !t.IsSigned() 614 // result: (Int64Make (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem) (Load <typ.UInt32> ptr mem)) 615 for { 616 t := v.Type 617 ptr := v_0 618 mem := v_1 619 if !(is64BitInt(t) && !config.BigEndian && !t.IsSigned()) { 620 break 621 } 622 v.reset(OpInt64Make) 623 v0 := b.NewValue0(v.Pos, OpLoad, typ.UInt32) 624 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr) 625 v1.AuxInt = int64ToAuxInt(4) 626 v1.AddArg(ptr) 627 v0.AddArg2(v1, mem) 628 v2 := b.NewValue0(v.Pos, OpLoad, typ.UInt32) 629 v2.AddArg2(ptr, mem) 630 v.AddArg2(v0, v2) 631 return true 632 } 633 // match: (Load <t> ptr mem) 634 // cond: is64BitInt(t) && config.BigEndian && t.IsSigned() 635 // result: (Int64Make (Load <typ.Int32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem)) 636 for { 637 t := v.Type 638 ptr := v_0 639 mem := v_1 640 if !(is64BitInt(t) && config.BigEndian && t.IsSigned()) { 641 break 642 } 643 v.reset(OpInt64Make) 644 v0 := b.NewValue0(v.Pos, OpLoad, typ.Int32) 645 v0.AddArg2(ptr, mem) 646 v1 := b.NewValue0(v.Pos, OpLoad, typ.UInt32) 647 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr) 648 v2.AuxInt = int64ToAuxInt(4) 649 v2.AddArg(ptr) 650 v1.AddArg2(v2, mem) 651 v.AddArg2(v0, v1) 652 return true 653 } 654 // match: (Load <t> ptr mem) 655 // cond: is64BitInt(t) && config.BigEndian && !t.IsSigned() 656 // result: (Int64Make (Load <typ.UInt32> ptr mem) (Load <typ.UInt32> (OffPtr <typ.UInt32Ptr> [4] ptr) mem)) 657 for { 658 t := v.Type 659 ptr := v_0 660 mem := v_1 661 if !(is64BitInt(t) && config.BigEndian && !t.IsSigned()) { 662 break 663 } 664 v.reset(OpInt64Make) 665 v0 := b.NewValue0(v.Pos, OpLoad, typ.UInt32) 666 v0.AddArg2(ptr, mem) 667 v1 := b.NewValue0(v.Pos, OpLoad, typ.UInt32) 668 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.UInt32Ptr) 669 v2.AuxInt = int64ToAuxInt(4) 670 v2.AddArg(ptr) 671 v1.AddArg2(v2, mem) 672 v.AddArg2(v0, v1) 673 return true 674 } 675 return false 676} 677func rewriteValuedec64_OpLsh16x64(v *Value) bool { 678 v_1 := v.Args[1] 679 v_0 := v.Args[0] 680 b := v.Block 681 typ := &b.Func.Config.Types 682 // match: (Lsh16x64 _ (Int64Make (Const32 [c]) _)) 683 // cond: c != 0 684 // result: (Const32 [0]) 685 for { 686 if v_1.Op != OpInt64Make { 687 break 688 } 689 v_1_0 := v_1.Args[0] 690 if v_1_0.Op != OpConst32 { 691 break 692 } 693 c := auxIntToInt32(v_1_0.AuxInt) 694 if !(c != 0) { 695 break 696 } 697 v.reset(OpConst32) 698 v.AuxInt = int32ToAuxInt(0) 699 return true 700 } 701 // match: (Lsh16x64 [c] x (Int64Make (Const32 [0]) lo)) 702 // result: (Lsh16x32 [c] x lo) 703 for { 704 c := auxIntToBool(v.AuxInt) 705 x := v_0 706 if v_1.Op != OpInt64Make { 707 break 708 } 709 lo := v_1.Args[1] 710 v_1_0 := v_1.Args[0] 711 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 712 break 713 } 714 v.reset(OpLsh16x32) 715 v.AuxInt = boolToAuxInt(c) 716 v.AddArg2(x, lo) 717 return true 718 } 719 // match: (Lsh16x64 x (Int64Make hi lo)) 720 // cond: hi.Op != OpConst32 721 // result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 722 for { 723 x := v_0 724 if v_1.Op != OpInt64Make { 725 break 726 } 727 lo := v_1.Args[1] 728 hi := v_1.Args[0] 729 if !(hi.Op != OpConst32) { 730 break 731 } 732 v.reset(OpLsh16x32) 733 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 734 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 735 v1.AddArg(hi) 736 v0.AddArg2(v1, lo) 737 v.AddArg2(x, v0) 738 return true 739 } 740 // match: (Lsh16x64 x y) 741 // result: (Lsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 742 for { 743 x := v_0 744 y := v_1 745 v.reset(OpLsh16x32) 746 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 747 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 748 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 749 v2.AddArg(y) 750 v1.AddArg(v2) 751 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 752 v3.AddArg(y) 753 v0.AddArg2(v1, v3) 754 v.AddArg2(x, v0) 755 return true 756 } 757} 758func rewriteValuedec64_OpLsh32x64(v *Value) bool { 759 v_1 := v.Args[1] 760 v_0 := v.Args[0] 761 b := v.Block 762 typ := &b.Func.Config.Types 763 // match: (Lsh32x64 _ (Int64Make (Const32 [c]) _)) 764 // cond: c != 0 765 // result: (Const32 [0]) 766 for { 767 if v_1.Op != OpInt64Make { 768 break 769 } 770 v_1_0 := v_1.Args[0] 771 if v_1_0.Op != OpConst32 { 772 break 773 } 774 c := auxIntToInt32(v_1_0.AuxInt) 775 if !(c != 0) { 776 break 777 } 778 v.reset(OpConst32) 779 v.AuxInt = int32ToAuxInt(0) 780 return true 781 } 782 // match: (Lsh32x64 [c] x (Int64Make (Const32 [0]) lo)) 783 // result: (Lsh32x32 [c] x lo) 784 for { 785 c := auxIntToBool(v.AuxInt) 786 x := v_0 787 if v_1.Op != OpInt64Make { 788 break 789 } 790 lo := v_1.Args[1] 791 v_1_0 := v_1.Args[0] 792 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 793 break 794 } 795 v.reset(OpLsh32x32) 796 v.AuxInt = boolToAuxInt(c) 797 v.AddArg2(x, lo) 798 return true 799 } 800 // match: (Lsh32x64 x (Int64Make hi lo)) 801 // cond: hi.Op != OpConst32 802 // result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 803 for { 804 x := v_0 805 if v_1.Op != OpInt64Make { 806 break 807 } 808 lo := v_1.Args[1] 809 hi := v_1.Args[0] 810 if !(hi.Op != OpConst32) { 811 break 812 } 813 v.reset(OpLsh32x32) 814 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 815 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 816 v1.AddArg(hi) 817 v0.AddArg2(v1, lo) 818 v.AddArg2(x, v0) 819 return true 820 } 821 // match: (Lsh32x64 x y) 822 // result: (Lsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 823 for { 824 x := v_0 825 y := v_1 826 v.reset(OpLsh32x32) 827 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 828 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 829 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 830 v2.AddArg(y) 831 v1.AddArg(v2) 832 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 833 v3.AddArg(y) 834 v0.AddArg2(v1, v3) 835 v.AddArg2(x, v0) 836 return true 837 } 838} 839func rewriteValuedec64_OpLsh64x16(v *Value) bool { 840 v_1 := v.Args[1] 841 v_0 := v.Args[0] 842 b := v.Block 843 typ := &b.Func.Config.Types 844 // match: (Lsh64x16 x s) 845 // result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x16 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux16 <typ.UInt32> (Int64Lo x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (Lsh32x16 <typ.UInt32> (Int64Lo x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32])))) (Lsh32x16 <typ.UInt32> (Int64Lo x) s)) 846 for { 847 x := v_0 848 s := v_1 849 v.reset(OpInt64Make) 850 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 851 v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 852 v2 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32) 853 v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 854 v3.AddArg(x) 855 v2.AddArg2(v3, s) 856 v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32) 857 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 858 v5.AddArg(x) 859 v6 := b.NewValue0(v.Pos, OpSub16, typ.UInt16) 860 v7 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) 861 v7.AuxInt = int16ToAuxInt(32) 862 v6.AddArg2(v7, s) 863 v4.AddArg2(v5, v6) 864 v1.AddArg2(v2, v4) 865 v8 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32) 866 v9 := b.NewValue0(v.Pos, OpSub16, typ.UInt16) 867 v9.AddArg2(s, v7) 868 v8.AddArg2(v5, v9) 869 v0.AddArg2(v1, v8) 870 v10 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32) 871 v10.AddArg2(v5, s) 872 v.AddArg2(v0, v10) 873 return true 874 } 875} 876func rewriteValuedec64_OpLsh64x32(v *Value) bool { 877 v_1 := v.Args[1] 878 v_0 := v.Args[0] 879 b := v.Block 880 typ := &b.Func.Config.Types 881 // match: (Lsh64x32 x s) 882 // result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x32 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Lsh32x32 <typ.UInt32> (Int64Lo x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32])))) (Lsh32x32 <typ.UInt32> (Int64Lo x) s)) 883 for { 884 x := v_0 885 s := v_1 886 v.reset(OpInt64Make) 887 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 888 v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 889 v2 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32) 890 v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 891 v3.AddArg(x) 892 v2.AddArg2(v3, s) 893 v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32) 894 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 895 v5.AddArg(x) 896 v6 := b.NewValue0(v.Pos, OpSub32, typ.UInt32) 897 v7 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 898 v7.AuxInt = int32ToAuxInt(32) 899 v6.AddArg2(v7, s) 900 v4.AddArg2(v5, v6) 901 v1.AddArg2(v2, v4) 902 v8 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32) 903 v9 := b.NewValue0(v.Pos, OpSub32, typ.UInt32) 904 v9.AddArg2(s, v7) 905 v8.AddArg2(v5, v9) 906 v0.AddArg2(v1, v8) 907 v10 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32) 908 v10.AddArg2(v5, s) 909 v.AddArg2(v0, v10) 910 return true 911 } 912} 913func rewriteValuedec64_OpLsh64x64(v *Value) bool { 914 v_1 := v.Args[1] 915 v_0 := v.Args[0] 916 b := v.Block 917 typ := &b.Func.Config.Types 918 // match: (Lsh64x64 _ (Int64Make (Const32 [c]) _)) 919 // cond: c != 0 920 // result: (Const64 [0]) 921 for { 922 if v_1.Op != OpInt64Make { 923 break 924 } 925 v_1_0 := v_1.Args[0] 926 if v_1_0.Op != OpConst32 { 927 break 928 } 929 c := auxIntToInt32(v_1_0.AuxInt) 930 if !(c != 0) { 931 break 932 } 933 v.reset(OpConst64) 934 v.AuxInt = int64ToAuxInt(0) 935 return true 936 } 937 // match: (Lsh64x64 [c] x (Int64Make (Const32 [0]) lo)) 938 // result: (Lsh64x32 [c] x lo) 939 for { 940 c := auxIntToBool(v.AuxInt) 941 x := v_0 942 if v_1.Op != OpInt64Make { 943 break 944 } 945 lo := v_1.Args[1] 946 v_1_0 := v_1.Args[0] 947 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 948 break 949 } 950 v.reset(OpLsh64x32) 951 v.AuxInt = boolToAuxInt(c) 952 v.AddArg2(x, lo) 953 return true 954 } 955 // match: (Lsh64x64 x (Int64Make hi lo)) 956 // cond: hi.Op != OpConst32 957 // result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 958 for { 959 x := v_0 960 if v_1.Op != OpInt64Make { 961 break 962 } 963 lo := v_1.Args[1] 964 hi := v_1.Args[0] 965 if !(hi.Op != OpConst32) { 966 break 967 } 968 v.reset(OpLsh64x32) 969 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 970 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 971 v1.AddArg(hi) 972 v0.AddArg2(v1, lo) 973 v.AddArg2(x, v0) 974 return true 975 } 976 // match: (Lsh64x64 x y) 977 // result: (Lsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 978 for { 979 x := v_0 980 y := v_1 981 v.reset(OpLsh64x32) 982 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 983 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 984 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 985 v2.AddArg(y) 986 v1.AddArg(v2) 987 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 988 v3.AddArg(y) 989 v0.AddArg2(v1, v3) 990 v.AddArg2(x, v0) 991 return true 992 } 993} 994func rewriteValuedec64_OpLsh64x8(v *Value) bool { 995 v_1 := v.Args[1] 996 v_0 := v.Args[0] 997 b := v.Block 998 typ := &b.Func.Config.Types 999 // match: (Lsh64x8 x s) 1000 // result: (Int64Make (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Lsh32x8 <typ.UInt32> (Int64Hi x) s) (Rsh32Ux8 <typ.UInt32> (Int64Lo x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (Lsh32x8 <typ.UInt32> (Int64Lo x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32])))) (Lsh32x8 <typ.UInt32> (Int64Lo x) s)) 1001 for { 1002 x := v_0 1003 s := v_1 1004 v.reset(OpInt64Make) 1005 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1006 v1 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1007 v2 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32) 1008 v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1009 v3.AddArg(x) 1010 v2.AddArg2(v3, s) 1011 v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32) 1012 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1013 v5.AddArg(x) 1014 v6 := b.NewValue0(v.Pos, OpSub8, typ.UInt8) 1015 v7 := b.NewValue0(v.Pos, OpConst8, typ.UInt8) 1016 v7.AuxInt = int8ToAuxInt(32) 1017 v6.AddArg2(v7, s) 1018 v4.AddArg2(v5, v6) 1019 v1.AddArg2(v2, v4) 1020 v8 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32) 1021 v9 := b.NewValue0(v.Pos, OpSub8, typ.UInt8) 1022 v9.AddArg2(s, v7) 1023 v8.AddArg2(v5, v9) 1024 v0.AddArg2(v1, v8) 1025 v10 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32) 1026 v10.AddArg2(v5, s) 1027 v.AddArg2(v0, v10) 1028 return true 1029 } 1030} 1031func rewriteValuedec64_OpLsh8x64(v *Value) bool { 1032 v_1 := v.Args[1] 1033 v_0 := v.Args[0] 1034 b := v.Block 1035 typ := &b.Func.Config.Types 1036 // match: (Lsh8x64 _ (Int64Make (Const32 [c]) _)) 1037 // cond: c != 0 1038 // result: (Const32 [0]) 1039 for { 1040 if v_1.Op != OpInt64Make { 1041 break 1042 } 1043 v_1_0 := v_1.Args[0] 1044 if v_1_0.Op != OpConst32 { 1045 break 1046 } 1047 c := auxIntToInt32(v_1_0.AuxInt) 1048 if !(c != 0) { 1049 break 1050 } 1051 v.reset(OpConst32) 1052 v.AuxInt = int32ToAuxInt(0) 1053 return true 1054 } 1055 // match: (Lsh8x64 [c] x (Int64Make (Const32 [0]) lo)) 1056 // result: (Lsh8x32 [c] x lo) 1057 for { 1058 c := auxIntToBool(v.AuxInt) 1059 x := v_0 1060 if v_1.Op != OpInt64Make { 1061 break 1062 } 1063 lo := v_1.Args[1] 1064 v_1_0 := v_1.Args[0] 1065 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1066 break 1067 } 1068 v.reset(OpLsh8x32) 1069 v.AuxInt = boolToAuxInt(c) 1070 v.AddArg2(x, lo) 1071 return true 1072 } 1073 // match: (Lsh8x64 x (Int64Make hi lo)) 1074 // cond: hi.Op != OpConst32 1075 // result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 1076 for { 1077 x := v_0 1078 if v_1.Op != OpInt64Make { 1079 break 1080 } 1081 lo := v_1.Args[1] 1082 hi := v_1.Args[0] 1083 if !(hi.Op != OpConst32) { 1084 break 1085 } 1086 v.reset(OpLsh8x32) 1087 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1088 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1089 v1.AddArg(hi) 1090 v0.AddArg2(v1, lo) 1091 v.AddArg2(x, v0) 1092 return true 1093 } 1094 // match: (Lsh8x64 x y) 1095 // result: (Lsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 1096 for { 1097 x := v_0 1098 y := v_1 1099 v.reset(OpLsh8x32) 1100 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1101 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1102 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1103 v2.AddArg(y) 1104 v1.AddArg(v2) 1105 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1106 v3.AddArg(y) 1107 v0.AddArg2(v1, v3) 1108 v.AddArg2(x, v0) 1109 return true 1110 } 1111} 1112func rewriteValuedec64_OpMul64(v *Value) bool { 1113 v_1 := v.Args[1] 1114 v_0 := v.Args[0] 1115 b := v.Block 1116 typ := &b.Func.Config.Types 1117 // match: (Mul64 x y) 1118 // result: (Int64Make (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Int64Lo x) (Int64Hi y)) (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Int64Hi x) (Int64Lo y)) (Select0 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))) (Select1 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y)))) 1119 for { 1120 x := v_0 1121 y := v_1 1122 v.reset(OpInt64Make) 1123 v0 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) 1124 v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 1125 v2 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1126 v2.AddArg(x) 1127 v3 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1128 v3.AddArg(y) 1129 v1.AddArg2(v2, v3) 1130 v4 := b.NewValue0(v.Pos, OpAdd32, typ.UInt32) 1131 v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32) 1132 v6 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1133 v6.AddArg(x) 1134 v7 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1135 v7.AddArg(y) 1136 v5.AddArg2(v6, v7) 1137 v8 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32) 1138 v9 := b.NewValue0(v.Pos, OpMul32uhilo, types.NewTuple(typ.UInt32, typ.UInt32)) 1139 v9.AddArg2(v2, v7) 1140 v8.AddArg(v9) 1141 v4.AddArg2(v5, v8) 1142 v0.AddArg2(v1, v4) 1143 v10 := b.NewValue0(v.Pos, OpSelect1, typ.UInt32) 1144 v10.AddArg(v9) 1145 v.AddArg2(v0, v10) 1146 return true 1147 } 1148} 1149func rewriteValuedec64_OpNeg64(v *Value) bool { 1150 v_0 := v.Args[0] 1151 b := v.Block 1152 // match: (Neg64 <t> x) 1153 // result: (Sub64 (Const64 <t> [0]) x) 1154 for { 1155 t := v.Type 1156 x := v_0 1157 v.reset(OpSub64) 1158 v0 := b.NewValue0(v.Pos, OpConst64, t) 1159 v0.AuxInt = int64ToAuxInt(0) 1160 v.AddArg2(v0, x) 1161 return true 1162 } 1163} 1164func rewriteValuedec64_OpNeq64(v *Value) bool { 1165 v_1 := v.Args[1] 1166 v_0 := v.Args[0] 1167 b := v.Block 1168 typ := &b.Func.Config.Types 1169 // match: (Neq64 x y) 1170 // result: (OrB (Neq32 (Int64Hi x) (Int64Hi y)) (Neq32 (Int64Lo x) (Int64Lo y))) 1171 for { 1172 x := v_0 1173 y := v_1 1174 v.reset(OpOrB) 1175 v0 := b.NewValue0(v.Pos, OpNeq32, typ.Bool) 1176 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1177 v1.AddArg(x) 1178 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1179 v2.AddArg(y) 1180 v0.AddArg2(v1, v2) 1181 v3 := b.NewValue0(v.Pos, OpNeq32, typ.Bool) 1182 v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1183 v4.AddArg(x) 1184 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1185 v5.AddArg(y) 1186 v3.AddArg2(v4, v5) 1187 v.AddArg2(v0, v3) 1188 return true 1189 } 1190} 1191func rewriteValuedec64_OpOr32(v *Value) bool { 1192 v_1 := v.Args[1] 1193 v_0 := v.Args[0] 1194 b := v.Block 1195 typ := &b.Func.Config.Types 1196 // match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y) 1197 // cond: c == 0 1198 // result: y 1199 for { 1200 if v.Type != typ.UInt32 { 1201 break 1202 } 1203 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { 1204 if v_0.Op != OpZeromask { 1205 continue 1206 } 1207 v_0_0 := v_0.Args[0] 1208 if v_0_0.Op != OpConst32 { 1209 continue 1210 } 1211 c := auxIntToInt32(v_0_0.AuxInt) 1212 y := v_1 1213 if !(c == 0) { 1214 continue 1215 } 1216 v.copyOf(y) 1217 return true 1218 } 1219 break 1220 } 1221 // match: (Or32 <typ.UInt32> (Zeromask (Const32 [c])) y) 1222 // cond: c != 0 1223 // result: (Const32 <typ.UInt32> [-1]) 1224 for { 1225 if v.Type != typ.UInt32 { 1226 break 1227 } 1228 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { 1229 if v_0.Op != OpZeromask { 1230 continue 1231 } 1232 v_0_0 := v_0.Args[0] 1233 if v_0_0.Op != OpConst32 { 1234 continue 1235 } 1236 c := auxIntToInt32(v_0_0.AuxInt) 1237 if !(c != 0) { 1238 continue 1239 } 1240 v.reset(OpConst32) 1241 v.Type = typ.UInt32 1242 v.AuxInt = int32ToAuxInt(-1) 1243 return true 1244 } 1245 break 1246 } 1247 return false 1248} 1249func rewriteValuedec64_OpOr64(v *Value) bool { 1250 v_1 := v.Args[1] 1251 v_0 := v.Args[0] 1252 b := v.Block 1253 typ := &b.Func.Config.Types 1254 // match: (Or64 x y) 1255 // result: (Int64Make (Or32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Or32 <typ.UInt32> (Int64Lo x) (Int64Lo y))) 1256 for { 1257 x := v_0 1258 y := v_1 1259 v.reset(OpInt64Make) 1260 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1261 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1262 v1.AddArg(x) 1263 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1264 v2.AddArg(y) 1265 v0.AddArg2(v1, v2) 1266 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1267 v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1268 v4.AddArg(x) 1269 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1270 v5.AddArg(y) 1271 v3.AddArg2(v4, v5) 1272 v.AddArg2(v0, v3) 1273 return true 1274 } 1275} 1276func rewriteValuedec64_OpRotateLeft16(v *Value) bool { 1277 v_1 := v.Args[1] 1278 v_0 := v.Args[0] 1279 // match: (RotateLeft16 x (Int64Make hi lo)) 1280 // result: (RotateLeft16 x lo) 1281 for { 1282 x := v_0 1283 if v_1.Op != OpInt64Make { 1284 break 1285 } 1286 lo := v_1.Args[1] 1287 v.reset(OpRotateLeft16) 1288 v.AddArg2(x, lo) 1289 return true 1290 } 1291 return false 1292} 1293func rewriteValuedec64_OpRotateLeft32(v *Value) bool { 1294 v_1 := v.Args[1] 1295 v_0 := v.Args[0] 1296 // match: (RotateLeft32 x (Int64Make hi lo)) 1297 // result: (RotateLeft32 x lo) 1298 for { 1299 x := v_0 1300 if v_1.Op != OpInt64Make { 1301 break 1302 } 1303 lo := v_1.Args[1] 1304 v.reset(OpRotateLeft32) 1305 v.AddArg2(x, lo) 1306 return true 1307 } 1308 return false 1309} 1310func rewriteValuedec64_OpRotateLeft64(v *Value) bool { 1311 v_1 := v.Args[1] 1312 v_0 := v.Args[0] 1313 // match: (RotateLeft64 x (Int64Make hi lo)) 1314 // result: (RotateLeft64 x lo) 1315 for { 1316 x := v_0 1317 if v_1.Op != OpInt64Make { 1318 break 1319 } 1320 lo := v_1.Args[1] 1321 v.reset(OpRotateLeft64) 1322 v.AddArg2(x, lo) 1323 return true 1324 } 1325 return false 1326} 1327func rewriteValuedec64_OpRotateLeft8(v *Value) bool { 1328 v_1 := v.Args[1] 1329 v_0 := v.Args[0] 1330 // match: (RotateLeft8 x (Int64Make hi lo)) 1331 // result: (RotateLeft8 x lo) 1332 for { 1333 x := v_0 1334 if v_1.Op != OpInt64Make { 1335 break 1336 } 1337 lo := v_1.Args[1] 1338 v.reset(OpRotateLeft8) 1339 v.AddArg2(x, lo) 1340 return true 1341 } 1342 return false 1343} 1344func rewriteValuedec64_OpRsh16Ux64(v *Value) bool { 1345 v_1 := v.Args[1] 1346 v_0 := v.Args[0] 1347 b := v.Block 1348 typ := &b.Func.Config.Types 1349 // match: (Rsh16Ux64 _ (Int64Make (Const32 [c]) _)) 1350 // cond: c != 0 1351 // result: (Const32 [0]) 1352 for { 1353 if v_1.Op != OpInt64Make { 1354 break 1355 } 1356 v_1_0 := v_1.Args[0] 1357 if v_1_0.Op != OpConst32 { 1358 break 1359 } 1360 c := auxIntToInt32(v_1_0.AuxInt) 1361 if !(c != 0) { 1362 break 1363 } 1364 v.reset(OpConst32) 1365 v.AuxInt = int32ToAuxInt(0) 1366 return true 1367 } 1368 // match: (Rsh16Ux64 [c] x (Int64Make (Const32 [0]) lo)) 1369 // result: (Rsh16Ux32 [c] x lo) 1370 for { 1371 c := auxIntToBool(v.AuxInt) 1372 x := v_0 1373 if v_1.Op != OpInt64Make { 1374 break 1375 } 1376 lo := v_1.Args[1] 1377 v_1_0 := v_1.Args[0] 1378 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1379 break 1380 } 1381 v.reset(OpRsh16Ux32) 1382 v.AuxInt = boolToAuxInt(c) 1383 v.AddArg2(x, lo) 1384 return true 1385 } 1386 // match: (Rsh16Ux64 x (Int64Make hi lo)) 1387 // cond: hi.Op != OpConst32 1388 // result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 1389 for { 1390 x := v_0 1391 if v_1.Op != OpInt64Make { 1392 break 1393 } 1394 lo := v_1.Args[1] 1395 hi := v_1.Args[0] 1396 if !(hi.Op != OpConst32) { 1397 break 1398 } 1399 v.reset(OpRsh16Ux32) 1400 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1401 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1402 v1.AddArg(hi) 1403 v0.AddArg2(v1, lo) 1404 v.AddArg2(x, v0) 1405 return true 1406 } 1407 // match: (Rsh16Ux64 x y) 1408 // result: (Rsh16Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 1409 for { 1410 x := v_0 1411 y := v_1 1412 v.reset(OpRsh16Ux32) 1413 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1414 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1415 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1416 v2.AddArg(y) 1417 v1.AddArg(v2) 1418 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1419 v3.AddArg(y) 1420 v0.AddArg2(v1, v3) 1421 v.AddArg2(x, v0) 1422 return true 1423 } 1424} 1425func rewriteValuedec64_OpRsh16x64(v *Value) bool { 1426 v_1 := v.Args[1] 1427 v_0 := v.Args[0] 1428 b := v.Block 1429 typ := &b.Func.Config.Types 1430 // match: (Rsh16x64 x (Int64Make (Const32 [c]) _)) 1431 // cond: c != 0 1432 // result: (Signmask (SignExt16to32 x)) 1433 for { 1434 x := v_0 1435 if v_1.Op != OpInt64Make { 1436 break 1437 } 1438 v_1_0 := v_1.Args[0] 1439 if v_1_0.Op != OpConst32 { 1440 break 1441 } 1442 c := auxIntToInt32(v_1_0.AuxInt) 1443 if !(c != 0) { 1444 break 1445 } 1446 v.reset(OpSignmask) 1447 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 1448 v0.AddArg(x) 1449 v.AddArg(v0) 1450 return true 1451 } 1452 // match: (Rsh16x64 [c] x (Int64Make (Const32 [0]) lo)) 1453 // result: (Rsh16x32 [c] x lo) 1454 for { 1455 c := auxIntToBool(v.AuxInt) 1456 x := v_0 1457 if v_1.Op != OpInt64Make { 1458 break 1459 } 1460 lo := v_1.Args[1] 1461 v_1_0 := v_1.Args[0] 1462 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1463 break 1464 } 1465 v.reset(OpRsh16x32) 1466 v.AuxInt = boolToAuxInt(c) 1467 v.AddArg2(x, lo) 1468 return true 1469 } 1470 // match: (Rsh16x64 x (Int64Make hi lo)) 1471 // cond: hi.Op != OpConst32 1472 // result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 1473 for { 1474 x := v_0 1475 if v_1.Op != OpInt64Make { 1476 break 1477 } 1478 lo := v_1.Args[1] 1479 hi := v_1.Args[0] 1480 if !(hi.Op != OpConst32) { 1481 break 1482 } 1483 v.reset(OpRsh16x32) 1484 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1485 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1486 v1.AddArg(hi) 1487 v0.AddArg2(v1, lo) 1488 v.AddArg2(x, v0) 1489 return true 1490 } 1491 // match: (Rsh16x64 x y) 1492 // result: (Rsh16x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 1493 for { 1494 x := v_0 1495 y := v_1 1496 v.reset(OpRsh16x32) 1497 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1498 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1499 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1500 v2.AddArg(y) 1501 v1.AddArg(v2) 1502 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1503 v3.AddArg(y) 1504 v0.AddArg2(v1, v3) 1505 v.AddArg2(x, v0) 1506 return true 1507 } 1508} 1509func rewriteValuedec64_OpRsh32Ux64(v *Value) bool { 1510 v_1 := v.Args[1] 1511 v_0 := v.Args[0] 1512 b := v.Block 1513 typ := &b.Func.Config.Types 1514 // match: (Rsh32Ux64 _ (Int64Make (Const32 [c]) _)) 1515 // cond: c != 0 1516 // result: (Const32 [0]) 1517 for { 1518 if v_1.Op != OpInt64Make { 1519 break 1520 } 1521 v_1_0 := v_1.Args[0] 1522 if v_1_0.Op != OpConst32 { 1523 break 1524 } 1525 c := auxIntToInt32(v_1_0.AuxInt) 1526 if !(c != 0) { 1527 break 1528 } 1529 v.reset(OpConst32) 1530 v.AuxInt = int32ToAuxInt(0) 1531 return true 1532 } 1533 // match: (Rsh32Ux64 [c] x (Int64Make (Const32 [0]) lo)) 1534 // result: (Rsh32Ux32 [c] x lo) 1535 for { 1536 c := auxIntToBool(v.AuxInt) 1537 x := v_0 1538 if v_1.Op != OpInt64Make { 1539 break 1540 } 1541 lo := v_1.Args[1] 1542 v_1_0 := v_1.Args[0] 1543 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1544 break 1545 } 1546 v.reset(OpRsh32Ux32) 1547 v.AuxInt = boolToAuxInt(c) 1548 v.AddArg2(x, lo) 1549 return true 1550 } 1551 // match: (Rsh32Ux64 x (Int64Make hi lo)) 1552 // cond: hi.Op != OpConst32 1553 // result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 1554 for { 1555 x := v_0 1556 if v_1.Op != OpInt64Make { 1557 break 1558 } 1559 lo := v_1.Args[1] 1560 hi := v_1.Args[0] 1561 if !(hi.Op != OpConst32) { 1562 break 1563 } 1564 v.reset(OpRsh32Ux32) 1565 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1566 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1567 v1.AddArg(hi) 1568 v0.AddArg2(v1, lo) 1569 v.AddArg2(x, v0) 1570 return true 1571 } 1572 // match: (Rsh32Ux64 x y) 1573 // result: (Rsh32Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 1574 for { 1575 x := v_0 1576 y := v_1 1577 v.reset(OpRsh32Ux32) 1578 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1579 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1580 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1581 v2.AddArg(y) 1582 v1.AddArg(v2) 1583 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1584 v3.AddArg(y) 1585 v0.AddArg2(v1, v3) 1586 v.AddArg2(x, v0) 1587 return true 1588 } 1589} 1590func rewriteValuedec64_OpRsh32x64(v *Value) bool { 1591 v_1 := v.Args[1] 1592 v_0 := v.Args[0] 1593 b := v.Block 1594 typ := &b.Func.Config.Types 1595 // match: (Rsh32x64 x (Int64Make (Const32 [c]) _)) 1596 // cond: c != 0 1597 // result: (Signmask x) 1598 for { 1599 x := v_0 1600 if v_1.Op != OpInt64Make { 1601 break 1602 } 1603 v_1_0 := v_1.Args[0] 1604 if v_1_0.Op != OpConst32 { 1605 break 1606 } 1607 c := auxIntToInt32(v_1_0.AuxInt) 1608 if !(c != 0) { 1609 break 1610 } 1611 v.reset(OpSignmask) 1612 v.AddArg(x) 1613 return true 1614 } 1615 // match: (Rsh32x64 [c] x (Int64Make (Const32 [0]) lo)) 1616 // result: (Rsh32x32 [c] x lo) 1617 for { 1618 c := auxIntToBool(v.AuxInt) 1619 x := v_0 1620 if v_1.Op != OpInt64Make { 1621 break 1622 } 1623 lo := v_1.Args[1] 1624 v_1_0 := v_1.Args[0] 1625 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1626 break 1627 } 1628 v.reset(OpRsh32x32) 1629 v.AuxInt = boolToAuxInt(c) 1630 v.AddArg2(x, lo) 1631 return true 1632 } 1633 // match: (Rsh32x64 x (Int64Make hi lo)) 1634 // cond: hi.Op != OpConst32 1635 // result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 1636 for { 1637 x := v_0 1638 if v_1.Op != OpInt64Make { 1639 break 1640 } 1641 lo := v_1.Args[1] 1642 hi := v_1.Args[0] 1643 if !(hi.Op != OpConst32) { 1644 break 1645 } 1646 v.reset(OpRsh32x32) 1647 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1648 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1649 v1.AddArg(hi) 1650 v0.AddArg2(v1, lo) 1651 v.AddArg2(x, v0) 1652 return true 1653 } 1654 // match: (Rsh32x64 x y) 1655 // result: (Rsh32x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 1656 for { 1657 x := v_0 1658 y := v_1 1659 v.reset(OpRsh32x32) 1660 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1661 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1662 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1663 v2.AddArg(y) 1664 v1.AddArg(v2) 1665 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1666 v3.AddArg(y) 1667 v0.AddArg2(v1, v3) 1668 v.AddArg2(x, v0) 1669 return true 1670 } 1671} 1672func rewriteValuedec64_OpRsh64Ux16(v *Value) bool { 1673 v_1 := v.Args[1] 1674 v_0 := v.Args[0] 1675 b := v.Block 1676 typ := &b.Func.Config.Types 1677 // match: (Rsh64Ux16 x s) 1678 // result: (Int64Make (Rsh32Ux16 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux16 <typ.UInt32> (Int64Lo x) s) (Lsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (Rsh32Ux16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32]))))) 1679 for { 1680 x := v_0 1681 s := v_1 1682 v.reset(OpInt64Make) 1683 v0 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32) 1684 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1685 v1.AddArg(x) 1686 v0.AddArg2(v1, s) 1687 v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1688 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1689 v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32) 1690 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1691 v5.AddArg(x) 1692 v4.AddArg2(v5, s) 1693 v6 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32) 1694 v7 := b.NewValue0(v.Pos, OpSub16, typ.UInt16) 1695 v8 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) 1696 v8.AuxInt = int16ToAuxInt(32) 1697 v7.AddArg2(v8, s) 1698 v6.AddArg2(v1, v7) 1699 v3.AddArg2(v4, v6) 1700 v9 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32) 1701 v10 := b.NewValue0(v.Pos, OpSub16, typ.UInt16) 1702 v10.AddArg2(s, v8) 1703 v9.AddArg2(v1, v10) 1704 v2.AddArg2(v3, v9) 1705 v.AddArg2(v0, v2) 1706 return true 1707 } 1708} 1709func rewriteValuedec64_OpRsh64Ux32(v *Value) bool { 1710 v_1 := v.Args[1] 1711 v_0 := v.Args[0] 1712 b := v.Block 1713 typ := &b.Func.Config.Types 1714 // match: (Rsh64Ux32 x s) 1715 // result: (Int64Make (Rsh32Ux32 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux32 <typ.UInt32> (Int64Lo x) s) (Lsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (Rsh32Ux32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32]))))) 1716 for { 1717 x := v_0 1718 s := v_1 1719 v.reset(OpInt64Make) 1720 v0 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32) 1721 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1722 v1.AddArg(x) 1723 v0.AddArg2(v1, s) 1724 v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1725 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1726 v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32) 1727 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1728 v5.AddArg(x) 1729 v4.AddArg2(v5, s) 1730 v6 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32) 1731 v7 := b.NewValue0(v.Pos, OpSub32, typ.UInt32) 1732 v8 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 1733 v8.AuxInt = int32ToAuxInt(32) 1734 v7.AddArg2(v8, s) 1735 v6.AddArg2(v1, v7) 1736 v3.AddArg2(v4, v6) 1737 v9 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32) 1738 v10 := b.NewValue0(v.Pos, OpSub32, typ.UInt32) 1739 v10.AddArg2(s, v8) 1740 v9.AddArg2(v1, v10) 1741 v2.AddArg2(v3, v9) 1742 v.AddArg2(v0, v2) 1743 return true 1744 } 1745} 1746func rewriteValuedec64_OpRsh64Ux64(v *Value) bool { 1747 v_1 := v.Args[1] 1748 v_0 := v.Args[0] 1749 b := v.Block 1750 typ := &b.Func.Config.Types 1751 // match: (Rsh64Ux64 _ (Int64Make (Const32 [c]) _)) 1752 // cond: c != 0 1753 // result: (Const64 [0]) 1754 for { 1755 if v_1.Op != OpInt64Make { 1756 break 1757 } 1758 v_1_0 := v_1.Args[0] 1759 if v_1_0.Op != OpConst32 { 1760 break 1761 } 1762 c := auxIntToInt32(v_1_0.AuxInt) 1763 if !(c != 0) { 1764 break 1765 } 1766 v.reset(OpConst64) 1767 v.AuxInt = int64ToAuxInt(0) 1768 return true 1769 } 1770 // match: (Rsh64Ux64 [c] x (Int64Make (Const32 [0]) lo)) 1771 // result: (Rsh64Ux32 [c] x lo) 1772 for { 1773 c := auxIntToBool(v.AuxInt) 1774 x := v_0 1775 if v_1.Op != OpInt64Make { 1776 break 1777 } 1778 lo := v_1.Args[1] 1779 v_1_0 := v_1.Args[0] 1780 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1781 break 1782 } 1783 v.reset(OpRsh64Ux32) 1784 v.AuxInt = boolToAuxInt(c) 1785 v.AddArg2(x, lo) 1786 return true 1787 } 1788 // match: (Rsh64Ux64 x (Int64Make hi lo)) 1789 // cond: hi.Op != OpConst32 1790 // result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 1791 for { 1792 x := v_0 1793 if v_1.Op != OpInt64Make { 1794 break 1795 } 1796 lo := v_1.Args[1] 1797 hi := v_1.Args[0] 1798 if !(hi.Op != OpConst32) { 1799 break 1800 } 1801 v.reset(OpRsh64Ux32) 1802 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1803 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1804 v1.AddArg(hi) 1805 v0.AddArg2(v1, lo) 1806 v.AddArg2(x, v0) 1807 return true 1808 } 1809 // match: (Rsh64Ux64 x y) 1810 // result: (Rsh64Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 1811 for { 1812 x := v_0 1813 y := v_1 1814 v.reset(OpRsh64Ux32) 1815 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1816 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1817 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1818 v2.AddArg(y) 1819 v1.AddArg(v2) 1820 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1821 v3.AddArg(y) 1822 v0.AddArg2(v1, v3) 1823 v.AddArg2(x, v0) 1824 return true 1825 } 1826} 1827func rewriteValuedec64_OpRsh64Ux8(v *Value) bool { 1828 v_1 := v.Args[1] 1829 v_0 := v.Args[0] 1830 b := v.Block 1831 typ := &b.Func.Config.Types 1832 // match: (Rsh64Ux8 x s) 1833 // result: (Int64Make (Rsh32Ux8 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux8 <typ.UInt32> (Int64Lo x) s) (Lsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (Rsh32Ux8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32]))))) 1834 for { 1835 x := v_0 1836 s := v_1 1837 v.reset(OpInt64Make) 1838 v0 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32) 1839 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1840 v1.AddArg(x) 1841 v0.AddArg2(v1, s) 1842 v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1843 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1844 v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32) 1845 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1846 v5.AddArg(x) 1847 v4.AddArg2(v5, s) 1848 v6 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32) 1849 v7 := b.NewValue0(v.Pos, OpSub8, typ.UInt8) 1850 v8 := b.NewValue0(v.Pos, OpConst8, typ.UInt8) 1851 v8.AuxInt = int8ToAuxInt(32) 1852 v7.AddArg2(v8, s) 1853 v6.AddArg2(v1, v7) 1854 v3.AddArg2(v4, v6) 1855 v9 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32) 1856 v10 := b.NewValue0(v.Pos, OpSub8, typ.UInt8) 1857 v10.AddArg2(s, v8) 1858 v9.AddArg2(v1, v10) 1859 v2.AddArg2(v3, v9) 1860 v.AddArg2(v0, v2) 1861 return true 1862 } 1863} 1864func rewriteValuedec64_OpRsh64x16(v *Value) bool { 1865 v_1 := v.Args[1] 1866 v_0 := v.Args[0] 1867 b := v.Block 1868 typ := &b.Func.Config.Types 1869 // match: (Rsh64x16 x s) 1870 // result: (Int64Make (Rsh32x16 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux16 <typ.UInt32> (Int64Lo x) s) (Lsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> (Const16 <typ.UInt16> [32]) s))) (And32 <typ.UInt32> (Rsh32x16 <typ.UInt32> (Int64Hi x) (Sub16 <typ.UInt16> s (Const16 <typ.UInt16> [32]))) (Zeromask (ZeroExt16to32 (Rsh16Ux32 <typ.UInt16> s (Const32 <typ.UInt32> [5]))))))) 1871 for { 1872 x := v_0 1873 s := v_1 1874 v.reset(OpInt64Make) 1875 v0 := b.NewValue0(v.Pos, OpRsh32x16, typ.UInt32) 1876 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1877 v1.AddArg(x) 1878 v0.AddArg2(v1, s) 1879 v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1880 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1881 v4 := b.NewValue0(v.Pos, OpRsh32Ux16, typ.UInt32) 1882 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1883 v5.AddArg(x) 1884 v4.AddArg2(v5, s) 1885 v6 := b.NewValue0(v.Pos, OpLsh32x16, typ.UInt32) 1886 v7 := b.NewValue0(v.Pos, OpSub16, typ.UInt16) 1887 v8 := b.NewValue0(v.Pos, OpConst16, typ.UInt16) 1888 v8.AuxInt = int16ToAuxInt(32) 1889 v7.AddArg2(v8, s) 1890 v6.AddArg2(v1, v7) 1891 v3.AddArg2(v4, v6) 1892 v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32) 1893 v10 := b.NewValue0(v.Pos, OpRsh32x16, typ.UInt32) 1894 v11 := b.NewValue0(v.Pos, OpSub16, typ.UInt16) 1895 v11.AddArg2(s, v8) 1896 v10.AddArg2(v1, v11) 1897 v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1898 v13 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 1899 v14 := b.NewValue0(v.Pos, OpRsh16Ux32, typ.UInt16) 1900 v15 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 1901 v15.AuxInt = int32ToAuxInt(5) 1902 v14.AddArg2(s, v15) 1903 v13.AddArg(v14) 1904 v12.AddArg(v13) 1905 v9.AddArg2(v10, v12) 1906 v2.AddArg2(v3, v9) 1907 v.AddArg2(v0, v2) 1908 return true 1909 } 1910} 1911func rewriteValuedec64_OpRsh64x32(v *Value) bool { 1912 v_1 := v.Args[1] 1913 v_0 := v.Args[0] 1914 b := v.Block 1915 typ := &b.Func.Config.Types 1916 // match: (Rsh64x32 x s) 1917 // result: (Int64Make (Rsh32x32 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux32 <typ.UInt32> (Int64Lo x) s) (Lsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> (Const32 <typ.UInt32> [32]) s))) (And32 <typ.UInt32> (Rsh32x32 <typ.UInt32> (Int64Hi x) (Sub32 <typ.UInt32> s (Const32 <typ.UInt32> [32]))) (Zeromask (Rsh32Ux32 <typ.UInt32> s (Const32 <typ.UInt32> [5])))))) 1918 for { 1919 x := v_0 1920 s := v_1 1921 v.reset(OpInt64Make) 1922 v0 := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32) 1923 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1924 v1.AddArg(x) 1925 v0.AddArg2(v1, s) 1926 v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1927 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 1928 v4 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32) 1929 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 1930 v5.AddArg(x) 1931 v4.AddArg2(v5, s) 1932 v6 := b.NewValue0(v.Pos, OpLsh32x32, typ.UInt32) 1933 v7 := b.NewValue0(v.Pos, OpSub32, typ.UInt32) 1934 v8 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 1935 v8.AuxInt = int32ToAuxInt(32) 1936 v7.AddArg2(v8, s) 1937 v6.AddArg2(v1, v7) 1938 v3.AddArg2(v4, v6) 1939 v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32) 1940 v10 := b.NewValue0(v.Pos, OpRsh32x32, typ.UInt32) 1941 v11 := b.NewValue0(v.Pos, OpSub32, typ.UInt32) 1942 v11.AddArg2(s, v8) 1943 v10.AddArg2(v1, v11) 1944 v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 1945 v13 := b.NewValue0(v.Pos, OpRsh32Ux32, typ.UInt32) 1946 v14 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 1947 v14.AuxInt = int32ToAuxInt(5) 1948 v13.AddArg2(s, v14) 1949 v12.AddArg(v13) 1950 v9.AddArg2(v10, v12) 1951 v2.AddArg2(v3, v9) 1952 v.AddArg2(v0, v2) 1953 return true 1954 } 1955} 1956func rewriteValuedec64_OpRsh64x64(v *Value) bool { 1957 v_1 := v.Args[1] 1958 v_0 := v.Args[0] 1959 b := v.Block 1960 typ := &b.Func.Config.Types 1961 // match: (Rsh64x64 x (Int64Make (Const32 [c]) _)) 1962 // cond: c != 0 1963 // result: (Int64Make (Signmask (Int64Hi x)) (Signmask (Int64Hi x))) 1964 for { 1965 x := v_0 1966 if v_1.Op != OpInt64Make { 1967 break 1968 } 1969 v_1_0 := v_1.Args[0] 1970 if v_1_0.Op != OpConst32 { 1971 break 1972 } 1973 c := auxIntToInt32(v_1_0.AuxInt) 1974 if !(c != 0) { 1975 break 1976 } 1977 v.reset(OpInt64Make) 1978 v0 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 1979 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 1980 v1.AddArg(x) 1981 v0.AddArg(v1) 1982 v.AddArg2(v0, v0) 1983 return true 1984 } 1985 // match: (Rsh64x64 [c] x (Int64Make (Const32 [0]) lo)) 1986 // result: (Rsh64x32 [c] x lo) 1987 for { 1988 c := auxIntToBool(v.AuxInt) 1989 x := v_0 1990 if v_1.Op != OpInt64Make { 1991 break 1992 } 1993 lo := v_1.Args[1] 1994 v_1_0 := v_1.Args[0] 1995 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 1996 break 1997 } 1998 v.reset(OpRsh64x32) 1999 v.AuxInt = boolToAuxInt(c) 2000 v.AddArg2(x, lo) 2001 return true 2002 } 2003 // match: (Rsh64x64 x (Int64Make hi lo)) 2004 // cond: hi.Op != OpConst32 2005 // result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 2006 for { 2007 x := v_0 2008 if v_1.Op != OpInt64Make { 2009 break 2010 } 2011 lo := v_1.Args[1] 2012 hi := v_1.Args[0] 2013 if !(hi.Op != OpConst32) { 2014 break 2015 } 2016 v.reset(OpRsh64x32) 2017 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2018 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2019 v1.AddArg(hi) 2020 v0.AddArg2(v1, lo) 2021 v.AddArg2(x, v0) 2022 return true 2023 } 2024 // match: (Rsh64x64 x y) 2025 // result: (Rsh64x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 2026 for { 2027 x := v_0 2028 y := v_1 2029 v.reset(OpRsh64x32) 2030 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2031 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2032 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2033 v2.AddArg(y) 2034 v1.AddArg(v2) 2035 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2036 v3.AddArg(y) 2037 v0.AddArg2(v1, v3) 2038 v.AddArg2(x, v0) 2039 return true 2040 } 2041} 2042func rewriteValuedec64_OpRsh64x8(v *Value) bool { 2043 v_1 := v.Args[1] 2044 v_0 := v.Args[0] 2045 b := v.Block 2046 typ := &b.Func.Config.Types 2047 // match: (Rsh64x8 x s) 2048 // result: (Int64Make (Rsh32x8 <typ.UInt32> (Int64Hi x) s) (Or32 <typ.UInt32> (Or32 <typ.UInt32> (Rsh32Ux8 <typ.UInt32> (Int64Lo x) s) (Lsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> (Const8 <typ.UInt8> [32]) s))) (And32 <typ.UInt32> (Rsh32x8 <typ.UInt32> (Int64Hi x) (Sub8 <typ.UInt8> s (Const8 <typ.UInt8> [32]))) (Zeromask (ZeroExt8to32 (Rsh8Ux32 <typ.UInt8> s (Const32 <typ.UInt32> [5]))))))) 2049 for { 2050 x := v_0 2051 s := v_1 2052 v.reset(OpInt64Make) 2053 v0 := b.NewValue0(v.Pos, OpRsh32x8, typ.UInt32) 2054 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2055 v1.AddArg(x) 2056 v0.AddArg2(v1, s) 2057 v2 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2058 v3 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2059 v4 := b.NewValue0(v.Pos, OpRsh32Ux8, typ.UInt32) 2060 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2061 v5.AddArg(x) 2062 v4.AddArg2(v5, s) 2063 v6 := b.NewValue0(v.Pos, OpLsh32x8, typ.UInt32) 2064 v7 := b.NewValue0(v.Pos, OpSub8, typ.UInt8) 2065 v8 := b.NewValue0(v.Pos, OpConst8, typ.UInt8) 2066 v8.AuxInt = int8ToAuxInt(32) 2067 v7.AddArg2(v8, s) 2068 v6.AddArg2(v1, v7) 2069 v3.AddArg2(v4, v6) 2070 v9 := b.NewValue0(v.Pos, OpAnd32, typ.UInt32) 2071 v10 := b.NewValue0(v.Pos, OpRsh32x8, typ.UInt32) 2072 v11 := b.NewValue0(v.Pos, OpSub8, typ.UInt8) 2073 v11.AddArg2(s, v8) 2074 v10.AddArg2(v1, v11) 2075 v12 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2076 v13 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 2077 v14 := b.NewValue0(v.Pos, OpRsh8Ux32, typ.UInt8) 2078 v15 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 2079 v15.AuxInt = int32ToAuxInt(5) 2080 v14.AddArg2(s, v15) 2081 v13.AddArg(v14) 2082 v12.AddArg(v13) 2083 v9.AddArg2(v10, v12) 2084 v2.AddArg2(v3, v9) 2085 v.AddArg2(v0, v2) 2086 return true 2087 } 2088} 2089func rewriteValuedec64_OpRsh8Ux64(v *Value) bool { 2090 v_1 := v.Args[1] 2091 v_0 := v.Args[0] 2092 b := v.Block 2093 typ := &b.Func.Config.Types 2094 // match: (Rsh8Ux64 _ (Int64Make (Const32 [c]) _)) 2095 // cond: c != 0 2096 // result: (Const32 [0]) 2097 for { 2098 if v_1.Op != OpInt64Make { 2099 break 2100 } 2101 v_1_0 := v_1.Args[0] 2102 if v_1_0.Op != OpConst32 { 2103 break 2104 } 2105 c := auxIntToInt32(v_1_0.AuxInt) 2106 if !(c != 0) { 2107 break 2108 } 2109 v.reset(OpConst32) 2110 v.AuxInt = int32ToAuxInt(0) 2111 return true 2112 } 2113 // match: (Rsh8Ux64 [c] x (Int64Make (Const32 [0]) lo)) 2114 // result: (Rsh8Ux32 [c] x lo) 2115 for { 2116 c := auxIntToBool(v.AuxInt) 2117 x := v_0 2118 if v_1.Op != OpInt64Make { 2119 break 2120 } 2121 lo := v_1.Args[1] 2122 v_1_0 := v_1.Args[0] 2123 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 2124 break 2125 } 2126 v.reset(OpRsh8Ux32) 2127 v.AuxInt = boolToAuxInt(c) 2128 v.AddArg2(x, lo) 2129 return true 2130 } 2131 // match: (Rsh8Ux64 x (Int64Make hi lo)) 2132 // cond: hi.Op != OpConst32 2133 // result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 2134 for { 2135 x := v_0 2136 if v_1.Op != OpInt64Make { 2137 break 2138 } 2139 lo := v_1.Args[1] 2140 hi := v_1.Args[0] 2141 if !(hi.Op != OpConst32) { 2142 break 2143 } 2144 v.reset(OpRsh8Ux32) 2145 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2146 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2147 v1.AddArg(hi) 2148 v0.AddArg2(v1, lo) 2149 v.AddArg2(x, v0) 2150 return true 2151 } 2152 // match: (Rsh8Ux64 x y) 2153 // result: (Rsh8Ux32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 2154 for { 2155 x := v_0 2156 y := v_1 2157 v.reset(OpRsh8Ux32) 2158 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2159 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2160 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2161 v2.AddArg(y) 2162 v1.AddArg(v2) 2163 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2164 v3.AddArg(y) 2165 v0.AddArg2(v1, v3) 2166 v.AddArg2(x, v0) 2167 return true 2168 } 2169} 2170func rewriteValuedec64_OpRsh8x64(v *Value) bool { 2171 v_1 := v.Args[1] 2172 v_0 := v.Args[0] 2173 b := v.Block 2174 typ := &b.Func.Config.Types 2175 // match: (Rsh8x64 x (Int64Make (Const32 [c]) _)) 2176 // cond: c != 0 2177 // result: (Signmask (SignExt8to32 x)) 2178 for { 2179 x := v_0 2180 if v_1.Op != OpInt64Make { 2181 break 2182 } 2183 v_1_0 := v_1.Args[0] 2184 if v_1_0.Op != OpConst32 { 2185 break 2186 } 2187 c := auxIntToInt32(v_1_0.AuxInt) 2188 if !(c != 0) { 2189 break 2190 } 2191 v.reset(OpSignmask) 2192 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 2193 v0.AddArg(x) 2194 v.AddArg(v0) 2195 return true 2196 } 2197 // match: (Rsh8x64 [c] x (Int64Make (Const32 [0]) lo)) 2198 // result: (Rsh8x32 [c] x lo) 2199 for { 2200 c := auxIntToBool(v.AuxInt) 2201 x := v_0 2202 if v_1.Op != OpInt64Make { 2203 break 2204 } 2205 lo := v_1.Args[1] 2206 v_1_0 := v_1.Args[0] 2207 if v_1_0.Op != OpConst32 || auxIntToInt32(v_1_0.AuxInt) != 0 { 2208 break 2209 } 2210 v.reset(OpRsh8x32) 2211 v.AuxInt = boolToAuxInt(c) 2212 v.AddArg2(x, lo) 2213 return true 2214 } 2215 // match: (Rsh8x64 x (Int64Make hi lo)) 2216 // cond: hi.Op != OpConst32 2217 // result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask hi) lo)) 2218 for { 2219 x := v_0 2220 if v_1.Op != OpInt64Make { 2221 break 2222 } 2223 lo := v_1.Args[1] 2224 hi := v_1.Args[0] 2225 if !(hi.Op != OpConst32) { 2226 break 2227 } 2228 v.reset(OpRsh8x32) 2229 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2230 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2231 v1.AddArg(hi) 2232 v0.AddArg2(v1, lo) 2233 v.AddArg2(x, v0) 2234 return true 2235 } 2236 // match: (Rsh8x64 x y) 2237 // result: (Rsh8x32 x (Or32 <typ.UInt32> (Zeromask (Int64Hi y)) (Int64Lo y))) 2238 for { 2239 x := v_0 2240 y := v_1 2241 v.reset(OpRsh8x32) 2242 v0 := b.NewValue0(v.Pos, OpOr32, typ.UInt32) 2243 v1 := b.NewValue0(v.Pos, OpZeromask, typ.UInt32) 2244 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2245 v2.AddArg(y) 2246 v1.AddArg(v2) 2247 v3 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2248 v3.AddArg(y) 2249 v0.AddArg2(v1, v3) 2250 v.AddArg2(x, v0) 2251 return true 2252 } 2253} 2254func rewriteValuedec64_OpSignExt16to64(v *Value) bool { 2255 v_0 := v.Args[0] 2256 b := v.Block 2257 typ := &b.Func.Config.Types 2258 // match: (SignExt16to64 x) 2259 // result: (SignExt32to64 (SignExt16to32 x)) 2260 for { 2261 x := v_0 2262 v.reset(OpSignExt32to64) 2263 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32) 2264 v0.AddArg(x) 2265 v.AddArg(v0) 2266 return true 2267 } 2268} 2269func rewriteValuedec64_OpSignExt32to64(v *Value) bool { 2270 v_0 := v.Args[0] 2271 b := v.Block 2272 typ := &b.Func.Config.Types 2273 // match: (SignExt32to64 x) 2274 // result: (Int64Make (Signmask x) x) 2275 for { 2276 x := v_0 2277 v.reset(OpInt64Make) 2278 v0 := b.NewValue0(v.Pos, OpSignmask, typ.Int32) 2279 v0.AddArg(x) 2280 v.AddArg2(v0, x) 2281 return true 2282 } 2283} 2284func rewriteValuedec64_OpSignExt8to64(v *Value) bool { 2285 v_0 := v.Args[0] 2286 b := v.Block 2287 typ := &b.Func.Config.Types 2288 // match: (SignExt8to64 x) 2289 // result: (SignExt32to64 (SignExt8to32 x)) 2290 for { 2291 x := v_0 2292 v.reset(OpSignExt32to64) 2293 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32) 2294 v0.AddArg(x) 2295 v.AddArg(v0) 2296 return true 2297 } 2298} 2299func rewriteValuedec64_OpStore(v *Value) bool { 2300 v_2 := v.Args[2] 2301 v_1 := v.Args[1] 2302 v_0 := v.Args[0] 2303 b := v.Block 2304 config := b.Func.Config 2305 // match: (Store {t} dst (Int64Make hi lo) mem) 2306 // cond: t.Size() == 8 && !config.BigEndian 2307 // result: (Store {hi.Type} (OffPtr <hi.Type.PtrTo()> [4] dst) hi (Store {lo.Type} dst lo mem)) 2308 for { 2309 t := auxToType(v.Aux) 2310 dst := v_0 2311 if v_1.Op != OpInt64Make { 2312 break 2313 } 2314 lo := v_1.Args[1] 2315 hi := v_1.Args[0] 2316 mem := v_2 2317 if !(t.Size() == 8 && !config.BigEndian) { 2318 break 2319 } 2320 v.reset(OpStore) 2321 v.Aux = typeToAux(hi.Type) 2322 v0 := b.NewValue0(v.Pos, OpOffPtr, hi.Type.PtrTo()) 2323 v0.AuxInt = int64ToAuxInt(4) 2324 v0.AddArg(dst) 2325 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 2326 v1.Aux = typeToAux(lo.Type) 2327 v1.AddArg3(dst, lo, mem) 2328 v.AddArg3(v0, hi, v1) 2329 return true 2330 } 2331 // match: (Store {t} dst (Int64Make hi lo) mem) 2332 // cond: t.Size() == 8 && config.BigEndian 2333 // result: (Store {lo.Type} (OffPtr <lo.Type.PtrTo()> [4] dst) lo (Store {hi.Type} dst hi mem)) 2334 for { 2335 t := auxToType(v.Aux) 2336 dst := v_0 2337 if v_1.Op != OpInt64Make { 2338 break 2339 } 2340 lo := v_1.Args[1] 2341 hi := v_1.Args[0] 2342 mem := v_2 2343 if !(t.Size() == 8 && config.BigEndian) { 2344 break 2345 } 2346 v.reset(OpStore) 2347 v.Aux = typeToAux(lo.Type) 2348 v0 := b.NewValue0(v.Pos, OpOffPtr, lo.Type.PtrTo()) 2349 v0.AuxInt = int64ToAuxInt(4) 2350 v0.AddArg(dst) 2351 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem) 2352 v1.Aux = typeToAux(hi.Type) 2353 v1.AddArg3(dst, hi, mem) 2354 v.AddArg3(v0, lo, v1) 2355 return true 2356 } 2357 return false 2358} 2359func rewriteValuedec64_OpSub64(v *Value) bool { 2360 v_1 := v.Args[1] 2361 v_0 := v.Args[0] 2362 b := v.Block 2363 typ := &b.Func.Config.Types 2364 // match: (Sub64 x y) 2365 // result: (Int64Make (Sub32withcarry <typ.Int32> (Int64Hi x) (Int64Hi y) (Select1 <types.TypeFlags> (Sub32carry (Int64Lo x) (Int64Lo y)))) (Select0 <typ.UInt32> (Sub32carry (Int64Lo x) (Int64Lo y)))) 2366 for { 2367 x := v_0 2368 y := v_1 2369 v.reset(OpInt64Make) 2370 v0 := b.NewValue0(v.Pos, OpSub32withcarry, typ.Int32) 2371 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2372 v1.AddArg(x) 2373 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2374 v2.AddArg(y) 2375 v3 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags) 2376 v4 := b.NewValue0(v.Pos, OpSub32carry, types.NewTuple(typ.UInt32, types.TypeFlags)) 2377 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2378 v5.AddArg(x) 2379 v6 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2380 v6.AddArg(y) 2381 v4.AddArg2(v5, v6) 2382 v3.AddArg(v4) 2383 v0.AddArg3(v1, v2, v3) 2384 v7 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32) 2385 v7.AddArg(v4) 2386 v.AddArg2(v0, v7) 2387 return true 2388 } 2389} 2390func rewriteValuedec64_OpTrunc64to16(v *Value) bool { 2391 v_0 := v.Args[0] 2392 b := v.Block 2393 typ := &b.Func.Config.Types 2394 // match: (Trunc64to16 (Int64Make _ lo)) 2395 // result: (Trunc32to16 lo) 2396 for { 2397 if v_0.Op != OpInt64Make { 2398 break 2399 } 2400 lo := v_0.Args[1] 2401 v.reset(OpTrunc32to16) 2402 v.AddArg(lo) 2403 return true 2404 } 2405 // match: (Trunc64to16 x) 2406 // result: (Trunc32to16 (Int64Lo x)) 2407 for { 2408 x := v_0 2409 v.reset(OpTrunc32to16) 2410 v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2411 v0.AddArg(x) 2412 v.AddArg(v0) 2413 return true 2414 } 2415} 2416func rewriteValuedec64_OpTrunc64to32(v *Value) bool { 2417 v_0 := v.Args[0] 2418 // match: (Trunc64to32 (Int64Make _ lo)) 2419 // result: lo 2420 for { 2421 if v_0.Op != OpInt64Make { 2422 break 2423 } 2424 lo := v_0.Args[1] 2425 v.copyOf(lo) 2426 return true 2427 } 2428 // match: (Trunc64to32 x) 2429 // result: (Int64Lo x) 2430 for { 2431 x := v_0 2432 v.reset(OpInt64Lo) 2433 v.AddArg(x) 2434 return true 2435 } 2436} 2437func rewriteValuedec64_OpTrunc64to8(v *Value) bool { 2438 v_0 := v.Args[0] 2439 b := v.Block 2440 typ := &b.Func.Config.Types 2441 // match: (Trunc64to8 (Int64Make _ lo)) 2442 // result: (Trunc32to8 lo) 2443 for { 2444 if v_0.Op != OpInt64Make { 2445 break 2446 } 2447 lo := v_0.Args[1] 2448 v.reset(OpTrunc32to8) 2449 v.AddArg(lo) 2450 return true 2451 } 2452 // match: (Trunc64to8 x) 2453 // result: (Trunc32to8 (Int64Lo x)) 2454 for { 2455 x := v_0 2456 v.reset(OpTrunc32to8) 2457 v0 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2458 v0.AddArg(x) 2459 v.AddArg(v0) 2460 return true 2461 } 2462} 2463func rewriteValuedec64_OpXor64(v *Value) bool { 2464 v_1 := v.Args[1] 2465 v_0 := v.Args[0] 2466 b := v.Block 2467 typ := &b.Func.Config.Types 2468 // match: (Xor64 x y) 2469 // result: (Int64Make (Xor32 <typ.UInt32> (Int64Hi x) (Int64Hi y)) (Xor32 <typ.UInt32> (Int64Lo x) (Int64Lo y))) 2470 for { 2471 x := v_0 2472 y := v_1 2473 v.reset(OpInt64Make) 2474 v0 := b.NewValue0(v.Pos, OpXor32, typ.UInt32) 2475 v1 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2476 v1.AddArg(x) 2477 v2 := b.NewValue0(v.Pos, OpInt64Hi, typ.UInt32) 2478 v2.AddArg(y) 2479 v0.AddArg2(v1, v2) 2480 v3 := b.NewValue0(v.Pos, OpXor32, typ.UInt32) 2481 v4 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2482 v4.AddArg(x) 2483 v5 := b.NewValue0(v.Pos, OpInt64Lo, typ.UInt32) 2484 v5.AddArg(y) 2485 v3.AddArg2(v4, v5) 2486 v.AddArg2(v0, v3) 2487 return true 2488 } 2489} 2490func rewriteValuedec64_OpZeroExt16to64(v *Value) bool { 2491 v_0 := v.Args[0] 2492 b := v.Block 2493 typ := &b.Func.Config.Types 2494 // match: (ZeroExt16to64 x) 2495 // result: (ZeroExt32to64 (ZeroExt16to32 x)) 2496 for { 2497 x := v_0 2498 v.reset(OpZeroExt32to64) 2499 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32) 2500 v0.AddArg(x) 2501 v.AddArg(v0) 2502 return true 2503 } 2504} 2505func rewriteValuedec64_OpZeroExt32to64(v *Value) bool { 2506 v_0 := v.Args[0] 2507 b := v.Block 2508 typ := &b.Func.Config.Types 2509 // match: (ZeroExt32to64 x) 2510 // result: (Int64Make (Const32 <typ.UInt32> [0]) x) 2511 for { 2512 x := v_0 2513 v.reset(OpInt64Make) 2514 v0 := b.NewValue0(v.Pos, OpConst32, typ.UInt32) 2515 v0.AuxInt = int32ToAuxInt(0) 2516 v.AddArg2(v0, x) 2517 return true 2518 } 2519} 2520func rewriteValuedec64_OpZeroExt8to64(v *Value) bool { 2521 v_0 := v.Args[0] 2522 b := v.Block 2523 typ := &b.Func.Config.Types 2524 // match: (ZeroExt8to64 x) 2525 // result: (ZeroExt32to64 (ZeroExt8to32 x)) 2526 for { 2527 x := v_0 2528 v.reset(OpZeroExt32to64) 2529 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32) 2530 v0.AddArg(x) 2531 v.AddArg(v0) 2532 return true 2533 } 2534} 2535func rewriteBlockdec64(b *Block) bool { 2536 return false 2537} 2538