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