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