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