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