test/codegen/arithmetic.go

   1 // asmcheck
   2
   3 // Copyright 2018 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 package codegen
   8
   9 // This file contains codegen tests related to arithmetic
  10 // simplifications and optimizations on integer types.
  11 // For codegen tests on float types, see floats.go.
  12
  13 // ----------------- //
  14 //    Subtraction    //
  15 // ----------------- //
  16
  17 var ef int
  18
  19 func SubMem(arr []int, b, c, d int) int {
  20         // 386:`SUBL\s[A-Z]+,\s8\([A-Z]+\)`
  21         // amd64:`SUBQ\s[A-Z]+,\s16\([A-Z]+\)`
  22         arr[2] -= b
  23         // 386:`SUBL\s[A-Z]+,\s12\([A-Z]+\)`
  24         // amd64:`SUBQ\s[A-Z]+,\s24\([A-Z]+\)`
  25         arr[3] -= b
  26         // 386:`DECL\s16\([A-Z]+\)`
  27         arr[4]--
  28         // 386:`ADDL\s[$]-20,\s20\([A-Z]+\)`
  29         arr[5] -= 20
  30         // 386:`SUBL\s\([A-Z]+\)\([A-Z]+\*4\),\s[A-Z]+`
  31         ef -= arr[b]
  32         // 386:`SUBL\s[A-Z]+,\s\([A-Z]+\)\([A-Z]+\*4\)`
  33         arr[c] -= b
  34         // 386:`ADDL\s[$]-15,\s\([A-Z]+\)\([A-Z]+\*4\)`
  35         arr[d] -= 15
  36         // 386:`DECL\s\([A-Z]+\)\([A-Z]+\*4\)`
  37         arr[b]--
  38         // amd64:`DECQ\s64\([A-Z]+\)`
  39         arr[8]--
  40         // 386:"SUBL\t4"
  41         // amd64:"SUBQ\t8"
  42         return arr[0] - arr[1]
  43 }
  44
  45 func SubFromConst(a int) int {
  46         // ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR`
  47         b := 40 - a
  48         return b
  49 }
  50
  51 func SubFromConstNeg(a int) int {
  52         // ppc64x: `ADD\t[$]40,\sR[0-9]+,\sR`
  53         c := 40 - (-a)
  54         return c
  55 }
  56
  57 func SubSubFromConst(a int) int {
  58         // ppc64x: `ADD\t[$]20,\sR[0-9]+,\sR`
  59         c := 40 - (20 - a)
  60         return c
  61 }
  62
  63 func AddSubFromConst(a int) int {
  64         // ppc64x: `SUBC\tR[0-9]+,\s[$]60,\sR`
  65         c := 40 + (20 - a)
  66         return c
  67 }
  68
  69 func NegSubFromConst(a int) int {
  70         // ppc64x: `ADD\t[$]-20,\sR[0-9]+,\sR`
  71         c := -(20 - a)
  72         return c
  73 }
  74
  75 func NegAddFromConstNeg(a int) int {
  76         // ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR`
  77         c := -(-40 + a)
  78         return c
  79 }
  80
  81 func SubSubNegSimplify(a, b int) int {
  82         // amd64:"NEGQ"
  83         // ppc64x:"NEG"
  84         r := (a - b) - a
  85         return r
  86 }
  87
  88 func SubAddSimplify(a, b int) int {
  89         // amd64:-"SUBQ",-"ADDQ"
  90         // ppc64x:-"SUB",-"ADD"
  91         r := a + (b - a)
  92         return r
  93 }
  94
  95 func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
  96         // amd64:-"ADDQ"
  97         r := (a + b) - (a + c)
  98         // amd64:-"ADDQ"
  99         r1 := (a + b) - (c + a)
 100         // amd64:-"ADDQ"
 101         r2 := (b + a) - (a + c)
 102         // amd64:-"ADDQ"
 103         r3 := (b + a) - (c + a)
 104         // amd64:-"SUBQ"
 105         r4 := (a - c) + (c + b)
 106         // amd64:-"SUBQ"
 107         r5 := (a - c) + (b + c)
 108         return r, r1, r2, r3, r4, r5
 109 }
 110
 111 func SubAddNegSimplify(a, b int) int {
 112         // amd64:"NEGQ",-"ADDQ",-"SUBQ"
 113         // ppc64x:"NEG",-"ADD",-"SUB"
 114         r := a - (b + a)
 115         return r
 116 }
 117
 118 func AddAddSubSimplify(a, b, c int) int {
 119         // amd64:-"SUBQ"
 120         // ppc64x:-"SUB"
 121         r := a + (b + (c - a))
 122         return r
 123 }
 124
 125 // -------------------- //
 126 //    Multiplication    //
 127 // -------------------- //
 128
 129 func Pow2Muls(n1, n2 int) (int, int) {
 130         // amd64:"SHLQ\t[$]5",-"IMULQ"
 131         // 386:"SHLL\t[$]5",-"IMULL"
 132         // arm:"SLL\t[$]5",-"MUL"
 133         // arm64:"LSL\t[$]5",-"MUL"
 134         // ppc64x:"SLD\t[$]5",-"MUL"
 135         a := n1 * 32
 136
 137         // amd64:"SHLQ\t[$]6",-"IMULQ"
 138         // 386:"SHLL\t[$]6",-"IMULL"
 139         // arm:"SLL\t[$]6",-"MUL"
 140         // arm64:`NEG\sR[0-9]+<<6,\sR[0-9]+`,-`LSL`,-`MUL`
 141         // ppc64x:"SLD\t[$]6","NEG\\sR[0-9]+,\\sR[0-9]+",-"MUL"
 142         b := -64 * n2
 143
 144         return a, b
 145 }
 146
 147 func Mul_96(n int) int {
 148         // amd64:`SHLQ\t[$]5`,`LEAQ\t\(.*\)\(.*\*2\),`,-`IMULQ`
 149         // 386:`SHLL\t[$]5`,`LEAL\t\(.*\)\(.*\*2\),`,-`IMULL`
 150         // arm64:`LSL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
 151         // arm:`SLL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
 152         // s390x:`SLD\t[$]5`,`SLD\t[$]6`,-`MULLD`
 153         return n * 96
 154 }
 155
 156 func Mul_n120(n int) int {
 157         // s390x:`SLD\t[$]3`,`SLD\t[$]7`,-`MULLD`
 158         return n * -120
 159 }
 160
 161 func MulMemSrc(a []uint32, b []float32) {
 162         // 386:`IMULL\s4\([A-Z]+\),\s[A-Z]+`
 163         a[0] *= a[1]
 164         // 386/sse2:`MULSS\s4\([A-Z]+\),\sX[0-9]+`
 165         // amd64:`MULSS\s4\([A-Z]+\),\sX[0-9]+`
 166         b[0] *= b[1]
 167 }
 168
 169 // Multiplications merging tests
 170
 171 func MergeMuls1(n int) int {
 172         // amd64:"IMUL3Q\t[$]46"
 173         // 386:"IMUL3L\t[$]46"
 174         // ppc64x:"MULLD\t[$]46"
 175         return 15*n + 31*n // 46n
 176 }
 177
 178 func MergeMuls2(n int) int {
 179         // amd64:"IMUL3Q\t[$]23","(ADDQ\t[$]29)|(LEAQ\t29)"
 180         // 386:"IMUL3L\t[$]23","ADDL\t[$]29"
 181         // ppc64x/power9:"MADDLD",-"MULLD\t[$]23",-"ADD\t[$]29"
 182         // ppc64x/power8:"MULLD\t[$]23","ADD\t[$]29"
 183         return 5*n + 7*(n+1) + 11*(n+2) // 23n + 29
 184 }
 185
 186 func MergeMuls3(a, n int) int {
 187         // amd64:"ADDQ\t[$]19",-"IMULQ\t[$]19"
 188         // 386:"ADDL\t[$]19",-"IMULL\t[$]19"
 189         // ppc64x:"ADD\t[$]19",-"MULLD\t[$]19"
 190         return a*n + 19*n // (a+19)n
 191 }
 192
 193 func MergeMuls4(n int) int {
 194         // amd64:"IMUL3Q\t[$]14"
 195         // 386:"IMUL3L\t[$]14"
 196         // ppc64x:"MULLD\t[$]14"
 197         return 23*n - 9*n // 14n
 198 }
 199
 200 func MergeMuls5(a, n int) int {
 201         // amd64:"ADDQ\t[$]-19",-"IMULQ\t[$]19"
 202         // 386:"ADDL\t[$]-19",-"IMULL\t[$]19"
 203         // ppc64x:"ADD\t[$]-19",-"MULLD\t[$]19"
 204         return a*n - 19*n // (a-19)n
 205 }
 206
 207 // -------------- //
 208 //    Division    //
 209 // -------------- //
 210
 211 func DivMemSrc(a []float64) {
 212         // 386/sse2:`DIVSD\s8\([A-Z]+\),\sX[0-9]+`
 213         // amd64:`DIVSD\s8\([A-Z]+\),\sX[0-9]+`
 214         a[0] /= a[1]
 215 }
 216
 217 func Pow2Divs(n1 uint, n2 int) (uint, int) {
 218         // 386:"SHRL\t[$]5",-"DIVL"
 219         // amd64:"SHRQ\t[$]5",-"DIVQ"
 220         // arm:"SRL\t[$]5",-".*udiv"
 221         // arm64:"LSR\t[$]5",-"UDIV"
 222         // ppc64x:"SRD"
 223         a := n1 / 32 // unsigned
 224
 225         // amd64:"SARQ\t[$]6",-"IDIVQ"
 226         // 386:"SARL\t[$]6",-"IDIVL"
 227         // arm:"SRA\t[$]6",-".*udiv"
 228         // arm64:"ASR\t[$]6",-"SDIV"
 229         // ppc64x:"SRAD"
 230         b := n2 / 64 // signed
 231
 232         return a, b
 233 }
 234
 235 // Check that constant divisions get turned into MULs
 236 func ConstDivs(n1 uint, n2 int) (uint, int) {
 237         // amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ"
 238         // 386:"MOVL\t[$]-252645135","MULL",-"DIVL"
 239         // arm64:`MOVD`,`UMULH`,-`DIV`
 240         // arm:`MOVW`,`MUL`,-`.*udiv`
 241         a := n1 / 17 // unsigned
 242
 243         // amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ"
 244         // 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL"
 245         // arm64:`SMULH`,-`DIV`
 246         // arm:`MOVW`,`MUL`,-`.*udiv`
 247         b := n2 / 17 // signed
 248
 249         return a, b
 250 }
 251
 252 func FloatDivs(a []float32) float32 {
 253         // amd64:`DIVSS\s8\([A-Z]+\),\sX[0-9]+`
 254         // 386/sse2:`DIVSS\s8\([A-Z]+\),\sX[0-9]+`
 255         return a[1] / a[2]
 256 }
 257
 258 func Pow2Mods(n1 uint, n2 int) (uint, int) {
 259         // 386:"ANDL\t[$]31",-"DIVL"
 260         // amd64:"ANDL\t[$]31",-"DIVQ"
 261         // arm:"AND\t[$]31",-".*udiv"
 262         // arm64:"AND\t[$]31",-"UDIV"
 263         // ppc64x:"RLDICL"
 264         a := n1 % 32 // unsigned
 265
 266         // 386:"SHRL",-"IDIVL"
 267         // amd64:"SHRQ",-"IDIVQ"
 268         // arm:"SRA",-".*udiv"
 269         // arm64:"ASR",-"REM"
 270         // ppc64x:"SRAD"
 271         b := n2 % 64 // signed
 272
 273         return a, b
 274 }
 275
 276 // Check that signed divisibility checks get converted to AND on low bits
 277 func Pow2DivisibleSigned(n1, n2 int) (bool, bool) {
 278         // 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
 279         // amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
 280         // arm:"AND\t[$]63",-".*udiv",-"SRA"
 281         // arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
 282         // ppc64x:"RLDICL",-"SRAD"
 283         a := n1%64 == 0 // signed divisible
 284
 285         // 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
 286         // amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
 287         // arm:"AND\t[$]63",-".*udiv",-"SRA"
 288         // arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
 289         // ppc64x:"RLDICL",-"SRAD"
 290         b := n2%64 != 0 // signed indivisible
 291
 292         return a, b
 293 }
 294
 295 // Check that constant modulo divs get turned into MULs
 296 func ConstMods(n1 uint, n2 int) (uint, int) {
 297         // amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ"
 298         // 386:"MOVL\t[$]-252645135","MULL",-"DIVL"
 299         // arm64:`MOVD`,`UMULH`,-`DIV`
 300         // arm:`MOVW`,`MUL`,-`.*udiv`
 301         a := n1 % 17 // unsigned
 302
 303         // amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ"
 304         // 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL"
 305         // arm64:`SMULH`,-`DIV`
 306         // arm:`MOVW`,`MUL`,-`.*udiv`
 307         b := n2 % 17 // signed
 308
 309         return a, b
 310 }
 311
 312 // Check that divisibility checks x%c==0 are converted to MULs and rotates
 313 func DivisibleU(n uint) (bool, bool) {
 314         // amd64:"MOVQ\t[$]-6148914691236517205","IMULQ","ROLQ\t[$]63",-"DIVQ"
 315         // 386:"IMUL3L\t[$]-1431655765","ROLL\t[$]31",-"DIVQ"
 316         // arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ROR",-"DIV"
 317         // arm:"MUL","CMP\t[$]715827882",-".*udiv"
 318         // ppc64x:"MULLD","ROTL\t[$]63"
 319         even := n%6 == 0
 320
 321         // amd64:"MOVQ\t[$]-8737931403336103397","IMULQ",-"ROLQ",-"DIVQ"
 322         // 386:"IMUL3L\t[$]678152731",-"ROLL",-"DIVQ"
 323         // arm64:"MOVD\t[$]-8737931403336103397","MUL",-"ROR",-"DIV"
 324         // arm:"MUL","CMP\t[$]226050910",-".*udiv"
 325         // ppc64x:"MULLD",-"ROTL"
 326         odd := n%19 == 0
 327
 328         return even, odd
 329 }
 330
 331 func Divisible(n int) (bool, bool) {
 332         // amd64:"IMULQ","ADD","ROLQ\t[$]63",-"DIVQ"
 333         // 386:"IMUL3L\t[$]-1431655765","ADDL\t[$]715827882","ROLL\t[$]31",-"DIVQ"
 334         // arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ADD\tR","ROR",-"DIV"
 335         // arm:"MUL","ADD\t[$]715827882",-".*udiv"
 336         // ppc64x/power8:"MULLD","ADD","ROTL\t[$]63"
 337         // ppc64x/power9:"MADDLD","ROTL\t[$]63"
 338         even := n%6 == 0
 339
 340         // amd64:"IMULQ","ADD",-"ROLQ",-"DIVQ"
 341         // 386:"IMUL3L\t[$]678152731","ADDL\t[$]113025455",-"ROLL",-"DIVQ"
 342         // arm64:"MUL","MOVD\t[$]485440633518672410","ADD",-"ROR",-"DIV"
 343         // arm:"MUL","ADD\t[$]113025455",-".*udiv"
 344         // ppc64x/power8:"MULLD","ADD",-"ROTL"
 345         // ppc64x/power9:"MADDLD",-"ROTL"
 346         odd := n%19 == 0
 347
 348         return even, odd
 349 }
 350
 351 // Check that fix-up code is not generated for divisions where it has been proven that
 352 // that the divisor is not -1 or that the dividend is > MinIntNN.
 353 func NoFix64A(divr int64) (int64, int64) {
 354         var d int64 = 42
 355         var e int64 = 84
 356         if divr > 5 {
 357                 d /= divr // amd64:-"JMP"
 358                 e %= divr // amd64:-"JMP"
 359                 // The following statement is to avoid conflict between the above check
 360                 // and the normal JMP generated at the end of the block.
 361                 d += e
 362         }
 363         return d, e
 364 }
 365
 366 func NoFix64B(divd int64) (int64, int64) {
 367         var d int64
 368         var e int64
 369         var divr int64 = -1
 370         if divd > -9223372036854775808 {
 371                 d = divd / divr // amd64:-"JMP"
 372                 e = divd % divr // amd64:-"JMP"
 373                 d += e
 374         }
 375         return d, e
 376 }
 377
 378 func NoFix32A(divr int32) (int32, int32) {
 379         var d int32 = 42
 380         var e int32 = 84
 381         if divr > 5 {
 382                 // amd64:-"JMP"
 383                 // 386:-"JMP"
 384                 d /= divr
 385                 // amd64:-"JMP"
 386                 // 386:-"JMP"
 387                 e %= divr
 388                 d += e
 389         }
 390         return d, e
 391 }
 392
 393 func NoFix32B(divd int32) (int32, int32) {
 394         var d int32
 395         var e int32
 396         var divr int32 = -1
 397         if divd > -2147483648 {
 398                 // amd64:-"JMP"
 399                 // 386:-"JMP"
 400                 d = divd / divr
 401                 // amd64:-"JMP"
 402                 // 386:-"JMP"
 403                 e = divd % divr
 404                 d += e
 405         }
 406         return d, e
 407 }
 408
 409 func NoFix16A(divr int16) (int16, int16) {
 410         var d int16 = 42
 411         var e int16 = 84
 412         if divr > 5 {
 413                 // amd64:-"JMP"
 414                 // 386:-"JMP"
 415                 d /= divr
 416                 // amd64:-"JMP"
 417                 // 386:-"JMP"
 418                 e %= divr
 419                 d += e
 420         }
 421         return d, e
 422 }
 423
 424 func NoFix16B(divd int16) (int16, int16) {
 425         var d int16
 426         var e int16
 427         var divr int16 = -1
 428         if divd > -32768 {
 429                 // amd64:-"JMP"
 430                 // 386:-"JMP"
 431                 d = divd / divr
 432                 // amd64:-"JMP"
 433                 // 386:-"JMP"
 434                 e = divd % divr
 435                 d += e
 436         }
 437         return d, e
 438 }
 439
 440 // Check that len() and cap() calls divided by powers of two are
 441 // optimized into shifts and ands
 442
 443 func LenDiv1(a []int) int {
 444         // 386:"SHRL\t[$]10"
 445         // amd64:"SHRQ\t[$]10"
 446         // arm64:"LSR\t[$]10",-"SDIV"
 447         // arm:"SRL\t[$]10",-".*udiv"
 448         // ppc64x:"SRD"\t[$]10"
 449         return len(a) / 1024
 450 }
 451
 452 func LenDiv2(s string) int {
 453         // 386:"SHRL\t[$]11"
 454         // amd64:"SHRQ\t[$]11"
 455         // arm64:"LSR\t[$]11",-"SDIV"
 456         // arm:"SRL\t[$]11",-".*udiv"
 457         // ppc64x:"SRD\t[$]11"
 458         return len(s) / (4097 >> 1)
 459 }
 460
 461 func LenMod1(a []int) int {
 462         // 386:"ANDL\t[$]1023"
 463         // amd64:"ANDL\t[$]1023"
 464         // arm64:"AND\t[$]1023",-"SDIV"
 465         // arm/6:"AND",-".*udiv"
 466         // arm/7:"BFC",-".*udiv",-"AND"
 467         // ppc64x:"RLDICL"
 468         return len(a) % 1024
 469 }
 470
 471 func LenMod2(s string) int {
 472         // 386:"ANDL\t[$]2047"
 473         // amd64:"ANDL\t[$]2047"
 474         // arm64:"AND\t[$]2047",-"SDIV"
 475         // arm/6:"AND",-".*udiv"
 476         // arm/7:"BFC",-".*udiv",-"AND"
 477         // ppc64x:"RLDICL"
 478         return len(s) % (4097 >> 1)
 479 }
 480
 481 func CapDiv(a []int) int {
 482         // 386:"SHRL\t[$]12"
 483         // amd64:"SHRQ\t[$]12"
 484         // arm64:"LSR\t[$]12",-"SDIV"
 485         // arm:"SRL\t[$]12",-".*udiv"
 486         // ppc64x:"SRD\t[$]12"
 487         return cap(a) / ((1 << 11) + 2048)
 488 }
 489
 490 func CapMod(a []int) int {
 491         // 386:"ANDL\t[$]4095"
 492         // amd64:"ANDL\t[$]4095"
 493         // arm64:"AND\t[$]4095",-"SDIV"
 494         // arm/6:"AND",-".*udiv"
 495         // arm/7:"BFC",-".*udiv",-"AND"
 496         // ppc64x:"RLDICL"
 497         return cap(a) % ((1 << 11) + 2048)
 498 }
 499
 500 func AddMul(x int) int {
 501         // amd64:"LEAQ\t1"
 502         return 2*x + 1
 503 }
 504
 505 func MULA(a, b, c uint32) (uint32, uint32, uint32) {
 506         // arm:`MULA`,-`MUL\s`
 507         // arm64:`MADDW`,-`MULW`
 508         r0 := a*b + c
 509         // arm:`MULA`,-`MUL\s`
 510         // arm64:`MADDW`,-`MULW`
 511         r1 := c*79 + a
 512         // arm:`ADD`,-`MULA`,-`MUL\s`
 513         // arm64:`ADD`,-`MADD`,-`MULW`
 514         // ppc64x:`ADD`,-`MULLD`
 515         r2 := b*64 + c
 516         return r0, r1, r2
 517 }
 518
 519 func MULS(a, b, c uint32) (uint32, uint32, uint32) {
 520         // arm/7:`MULS`,-`MUL\s`
 521         // arm/6:`SUB`,`MUL\s`,-`MULS`
 522         // arm64:`MSUBW`,-`MULW`
 523         r0 := c - a*b
 524         // arm/7:`MULS`,-`MUL\s`
 525         // arm/6:`SUB`,`MUL\s`,-`MULS`
 526         // arm64:`MSUBW`,-`MULW`
 527         r1 := a - c*79
 528         // arm/7:`SUB`,-`MULS`,-`MUL\s`
 529         // arm64:`SUB`,-`MSUBW`,-`MULW`
 530         // ppc64x:`SUB`,-`MULLD`
 531         r2 := c - b*64
 532         return r0, r1, r2
 533 }
 534
 535 func addSpecial(a, b, c uint32) (uint32, uint32, uint32) {
 536         // amd64:`INCL`
 537         a++
 538         // amd64:`DECL`
 539         b--
 540         // amd64:`SUBL.*-128`
 541         c += 128
 542         return a, b, c
 543 }
 544
 545 // Divide -> shift rules usually require fixup for negative inputs.
 546 // If the input is non-negative, make sure the fixup is eliminated.
 547 func divInt(v int64) int64 {
 548         if v < 0 {
 549                 return 0
 550         }
 551         // amd64:-`.*SARQ.*63,`, -".*SHRQ", ".*SARQ.*[$]9,"
 552         return v / 512
 553 }
 554
 555 // The reassociate rules "x - (z + C) -> (x - z) - C" and
 556 // "(z + C) -x -> C + (z - x)" can optimize the following cases.
 557 func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
 558         // arm64:"SUB","ADD\t[$]2"
 559         // ppc64x:"SUB","ADD\t[$]2"
 560         r0 := (i0 + 3) - (j0 + 1)
 561         // arm64:"SUB","SUB\t[$]4"
 562         // ppc64x:"SUB","ADD\t[$]-4"
 563         r1 := (i1 - 3) - (j1 + 1)
 564         // arm64:"SUB","ADD\t[$]4"
 565         // ppc64x:"SUB","ADD\t[$]4"
 566         r2 := (i2 + 3) - (j2 - 1)
 567         // arm64:"SUB","SUB\t[$]2"
 568         // ppc64x:"SUB","ADD\t[$]-2"
 569         r3 := (i3 - 3) - (j3 - 1)
 570         return r0, r1, r2, r3
 571 }
 572
 573 // The reassociate rules "x - (z + C) -> (x - z) - C" and
 574 // "(C - z) - x -> C - (z + x)" can optimize the following cases.
 575 func constantFold2(i0, j0, i1, j1 int) (int, int) {
 576         // arm64:"ADD","MOVD\t[$]2","SUB"
 577         // ppc64x: `SUBC\tR[0-9]+,\s[$]2,\sR`
 578         r0 := (3 - i0) - (j0 + 1)
 579         // arm64:"ADD","MOVD\t[$]4","SUB"
 580         // ppc64x: `SUBC\tR[0-9]+,\s[$]4,\sR`
 581         r1 := (3 - i1) - (j1 - 1)
 582         return r0, r1
 583 }
 584
 585 func constantFold3(i, j int) int {
 586         // arm64: "MOVD\t[$]30","MUL",-"ADD",-"LSL"
 587         // ppc64x:"MULLD\t[$]30","MULLD"
 588         r := (5 * i) * (6 * j)
 589         return r
 590 }