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