test/codegen/mathbits.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 import "math/bits"
  10
  11 // ----------------------- //
  12 //    bits.LeadingZeros    //
  13 // ----------------------- //
  14
  15 func LeadingZeros(n uint) int {
  16         // amd64:"BSRQ"
  17         // s390x:"FLOGR"
  18         // arm:"CLZ" arm64:"CLZ"
  19         // mips:"CLZ"
  20         return bits.LeadingZeros(n)
  21 }
  22
  23 func LeadingZeros64(n uint64) int {
  24         // amd64:"BSRQ"
  25         // s390x:"FLOGR"
  26         // arm:"CLZ" arm64:"CLZ"
  27         // mips:"CLZ"
  28         return bits.LeadingZeros64(n)
  29 }
  30
  31 func LeadingZeros32(n uint32) int {
  32         // amd64:"BSRQ","LEAQ",-"CMOVQEQ"
  33         // s390x:"FLOGR"
  34         // arm:"CLZ" arm64:"CLZW"
  35         // mips:"CLZ"
  36         return bits.LeadingZeros32(n)
  37 }
  38
  39 func LeadingZeros16(n uint16) int {
  40         // amd64:"BSRL","LEAL",-"CMOVQEQ"
  41         // s390x:"FLOGR"
  42         // arm:"CLZ" arm64:"CLZ"
  43         // mips:"CLZ"
  44         return bits.LeadingZeros16(n)
  45 }
  46
  47 func LeadingZeros8(n uint8) int {
  48         // amd64:"BSRL","LEAL",-"CMOVQEQ"
  49         // s390x:"FLOGR"
  50         // arm:"CLZ" arm64:"CLZ"
  51         // mips:"CLZ"
  52         return bits.LeadingZeros8(n)
  53 }
  54
  55 // --------------- //
  56 //    bits.Len*    //
  57 // --------------- //
  58
  59 func Len(n uint) int {
  60         // amd64:"BSRQ"
  61         // s390x:"FLOGR"
  62         // arm:"CLZ" arm64:"CLZ"
  63         // mips:"CLZ"
  64         return bits.Len(n)
  65 }
  66
  67 func Len64(n uint64) int {
  68         // amd64:"BSRQ"
  69         // s390x:"FLOGR"
  70         // arm:"CLZ" arm64:"CLZ"
  71         // mips:"CLZ"
  72         return bits.Len64(n)
  73 }
  74
  75 func Len32(n uint32) int {
  76         // amd64:"BSRQ","LEAQ",-"CMOVQEQ"
  77         // s390x:"FLOGR"
  78         // arm:"CLZ" arm64:"CLZ"
  79         // mips:"CLZ"
  80         return bits.Len32(n)
  81 }
  82
  83 func Len16(n uint16) int {
  84         // amd64:"BSRL","LEAL",-"CMOVQEQ"
  85         // s390x:"FLOGR"
  86         // arm:"CLZ" arm64:"CLZ"
  87         // mips:"CLZ"
  88         return bits.Len16(n)
  89 }
  90
  91 func Len8(n uint8) int {
  92         // amd64:"BSRL","LEAL",-"CMOVQEQ"
  93         // s390x:"FLOGR"
  94         // arm:"CLZ" arm64:"CLZ"
  95         // mips:"CLZ"
  96         return bits.Len8(n)
  97 }
  98
  99 // -------------------- //
 100 //    bits.OnesCount    //
 101 // -------------------- //
 102
 103 func OnesCount(n uint) int {
 104         // amd64:"POPCNTQ",".*x86HasPOPCNT"
 105         // arm64:"VCNT","VUADDLV"
 106         // s390x:"POPCNT"
 107         // ppc64:"POPCNTD"
 108         // ppc64le:"POPCNTD"
 109         return bits.OnesCount(n)
 110 }
 111
 112 func OnesCount64(n uint64) int {
 113         // amd64:"POPCNTQ",".*x86HasPOPCNT"
 114         // arm64:"VCNT","VUADDLV"
 115         // s390x:"POPCNT"
 116         // ppc64:"POPCNTD"
 117         // ppc64le:"POPCNTD"
 118         return bits.OnesCount64(n)
 119 }
 120
 121 func OnesCount32(n uint32) int {
 122         // amd64:"POPCNTL",".*x86HasPOPCNT"
 123         // arm64:"VCNT","VUADDLV"
 124         // s390x:"POPCNT"
 125         // ppc64:"POPCNTW"
 126         // ppc64le:"POPCNTW"
 127         return bits.OnesCount32(n)
 128 }
 129
 130 func OnesCount16(n uint16) int {
 131         // amd64:"POPCNTL",".*x86HasPOPCNT"
 132         // arm64:"VCNT","VUADDLV"
 133         // s390x:"POPCNT"
 134         // ppc64:"POPCNTW"
 135         // ppc64le:"POPCNTW"
 136         return bits.OnesCount16(n)
 137 }
 138
 139 func OnesCount8(n uint8) int {
 140         // s390x:"POPCNT"
 141         // ppc64:"POPCNTB"
 142         // ppc64le:"POPCNTB"
 143         return bits.OnesCount8(n)
 144 }
 145
 146 // ----------------------- //
 147 //    bits.ReverseBytes    //
 148 // ----------------------- //
 149
 150 func ReverseBytes(n uint) uint {
 151         // amd64:"BSWAPQ"
 152         // s390x:"MOVDBR"
 153         // arm64:"REV"
 154         return bits.ReverseBytes(n)
 155 }
 156
 157 func ReverseBytes64(n uint64) uint64 {
 158         // amd64:"BSWAPQ"
 159         // s390x:"MOVDBR"
 160         // arm64:"REV"
 161         return bits.ReverseBytes64(n)
 162 }
 163
 164 func ReverseBytes32(n uint32) uint32 {
 165         // amd64:"BSWAPL"
 166         // s390x:"MOVWBR"
 167         // arm64:"REVW"
 168         return bits.ReverseBytes32(n)
 169 }
 170
 171 func ReverseBytes16(n uint16) uint16 {
 172         // amd64:"ROLW"
 173         // arm64:"REV16W",-"UBFX",-"ORR"
 174         return bits.ReverseBytes16(n)
 175 }
 176
 177 // --------------------- //
 178 //    bits.RotateLeft    //
 179 // --------------------- //
 180
 181 func RotateLeft64(n uint64) uint64 {
 182         // amd64:"ROLQ"
 183         // arm64:"ROR"
 184         // ppc64:"ROTL"
 185         // ppc64le:"ROTL"
 186         // s390x:"RLLG"
 187         return bits.RotateLeft64(n, 37)
 188 }
 189
 190 func RotateLeft32(n uint32) uint32 {
 191         // amd64:"ROLL" 386:"ROLL"
 192         // arm64:"RORW"
 193         // ppc64:"ROTLW"
 194         // ppc64le:"ROTLW"
 195         // s390x:"RLL"
 196         return bits.RotateLeft32(n, 9)
 197 }
 198
 199 func RotateLeft16(n uint16) uint16 {
 200         // amd64:"ROLW" 386:"ROLW"
 201         return bits.RotateLeft16(n, 5)
 202 }
 203
 204 func RotateLeft8(n uint8) uint8 {
 205         // amd64:"ROLB" 386:"ROLB"
 206         return bits.RotateLeft8(n, 5)
 207 }
 208
 209 func RotateLeftVariable(n uint, m int) uint {
 210         // amd64:"ROLQ"
 211         // arm64:"ROR"
 212         // ppc64:"ROTL"
 213         // ppc64le:"ROTL"
 214         // s390x:"RLLG"
 215         return bits.RotateLeft(n, m)
 216 }
 217
 218 func RotateLeftVariable64(n uint64, m int) uint64 {
 219         // amd64:"ROLQ"
 220         // arm64:"ROR"
 221         // ppc64:"ROTL"
 222         // ppc64le:"ROTL"
 223         // s390x:"RLLG"
 224         return bits.RotateLeft64(n, m)
 225 }
 226
 227 func RotateLeftVariable32(n uint32, m int) uint32 {
 228         // amd64:"ROLL"
 229         // arm64:"RORW"
 230         // ppc64:"ROTLW"
 231         // ppc64le:"ROTLW"
 232         // s390x:"RLL"
 233         return bits.RotateLeft32(n, m)
 234 }
 235
 236 // ------------------------ //
 237 //    bits.TrailingZeros    //
 238 // ------------------------ //
 239
 240 func TrailingZeros(n uint) int {
 241         // amd64:"BSFQ","MOVL\t\\$64","CMOVQEQ"
 242         // s390x:"FLOGR"
 243         // ppc64:"ANDN","POPCNTD"
 244         // ppc64le:"ANDN","POPCNTD"
 245         return bits.TrailingZeros(n)
 246 }
 247
 248 func TrailingZeros64(n uint64) int {
 249         // amd64:"BSFQ","MOVL\t\\$64","CMOVQEQ"
 250         // s390x:"FLOGR"
 251         // ppc64:"ANDN","POPCNTD"
 252         // ppc64le:"ANDN","POPCNTD"
 253         return bits.TrailingZeros64(n)
 254 }
 255
 256 func TrailingZeros32(n uint32) int {
 257         // amd64:"BTSQ\\t\\$32","BSFQ"
 258         // s390x:"FLOGR","MOVWZ"
 259         // ppc64:"ANDN","POPCNTW"
 260         // ppc64le:"ANDN","POPCNTW"
 261         return bits.TrailingZeros32(n)
 262 }
 263
 264 func TrailingZeros16(n uint16) int {
 265         // amd64:"BSFL","BTSL\\t\\$16"
 266         // s390x:"FLOGR","OR\t\\$65536"
 267         // ppc64:"POPCNTD","OR\\t\\$65536"
 268         // ppc64le:"POPCNTD","OR\\t\\$65536"
 269         return bits.TrailingZeros16(n)
 270 }
 271
 272 func TrailingZeros8(n uint8) int {
 273         // amd64:"BSFL","BTSL\\t\\$8"
 274         // s390x:"FLOGR","OR\t\\$256"
 275         return bits.TrailingZeros8(n)
 276 }
 277
 278 // IterateBitsNN checks special handling of TrailingZerosNN when the input is known to be non-zero.
 279
 280 func IterateBits(n uint) int {
 281         i := 0
 282         for n != 0 {
 283                 // amd64:"BSFQ",-"CMOVEQ"
 284                 i += bits.TrailingZeros(n)
 285                 n &= n - 1
 286         }
 287         return i
 288 }
 289
 290 func IterateBits64(n uint64) int {
 291         i := 0
 292         for n != 0 {
 293                 // amd64:"BSFQ",-"CMOVEQ"
 294                 i += bits.TrailingZeros64(n)
 295                 n &= n - 1
 296         }
 297         return i
 298 }
 299
 300 func IterateBits32(n uint32) int {
 301         i := 0
 302         for n != 0 {
 303                 // amd64:"BSFL",-"BTSQ"
 304                 i += bits.TrailingZeros32(n)
 305                 n &= n - 1
 306         }
 307         return i
 308 }
 309
 310 func IterateBits16(n uint16) int {
 311         i := 0
 312         for n != 0 {
 313                 // amd64:"BSFL",-"BTSL"
 314                 i += bits.TrailingZeros16(n)
 315                 n &= n - 1
 316         }
 317         return i
 318 }
 319
 320 func IterateBits8(n uint8) int {
 321         i := 0
 322         for n != 0 {
 323                 // amd64:"BSFL",-"BTSL"
 324                 i += bits.TrailingZeros8(n)
 325                 n &= n - 1
 326         }
 327         return i
 328 }
 329
 330 // --------------- //
 331 //    bits.Add*    //
 332 // --------------- //
 333
 334 func Add(x, y, ci uint) (r, co uint) {
 335         // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
 336         return bits.Add(x, y, ci)
 337 }
 338
 339 func AddC(x, ci uint) (r, co uint) {
 340         // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
 341         return bits.Add(x, 7, ci)
 342 }
 343
 344 func AddZ(x, y uint) (r, co uint) {
 345         // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
 346         return bits.Add(x, y, 0)
 347 }
 348
 349 func AddR(x, y, ci uint) uint {
 350         // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
 351         r, _ := bits.Add(x, y, ci)
 352         return r
 353 }
 354 func AddM(p, q, r *[3]uint) {
 355         var c uint
 356         r[0], c = bits.Add(p[0], q[0], c)
 357         // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
 358         r[1], c = bits.Add(p[1], q[1], c)
 359         r[2], c = bits.Add(p[2], q[2], c)
 360 }
 361
 362 func Add64(x, y, ci uint64) (r, co uint64) {
 363         // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
 364         return bits.Add64(x, y, ci)
 365 }
 366
 367 func Add64C(x, ci uint64) (r, co uint64) {
 368         // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
 369         return bits.Add64(x, 7, ci)
 370 }
 371
 372 func Add64Z(x, y uint64) (r, co uint64) {
 373         // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
 374         return bits.Add64(x, y, 0)
 375 }
 376
 377 func Add64R(x, y, ci uint64) uint64 {
 378         // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
 379         r, _ := bits.Add64(x, y, ci)
 380         return r
 381 }
 382 func Add64M(p, q, r *[3]uint64) {
 383         var c uint64
 384         r[0], c = bits.Add64(p[0], q[0], c)
 385         // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
 386         r[1], c = bits.Add64(p[1], q[1], c)
 387         r[2], c = bits.Add64(p[2], q[2], c)
 388 }
 389
 390 // --------------- //
 391 //    bits.Sub*    //
 392 // --------------- //
 393
 394 func Sub(x, y, ci uint) (r, co uint) {
 395         // amd64:"NEGL","SBBQ","NEGQ"
 396         return bits.Sub(x, y, ci)
 397 }
 398
 399 func SubC(x, ci uint) (r, co uint) {
 400         // amd64:"NEGL","SBBQ","NEGQ"
 401         return bits.Sub(x, 7, ci)
 402 }
 403
 404 func SubZ(x, y uint) (r, co uint) {
 405         // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
 406         return bits.Sub(x, y, 0)
 407 }
 408
 409 func SubR(x, y, ci uint) uint {
 410         // amd64:"NEGL","SBBQ",-"NEGQ"
 411         r, _ := bits.Sub(x, y, ci)
 412         return r
 413 }
 414 func SubM(p, q, r *[3]uint) {
 415         var c uint
 416         r[0], c = bits.Sub(p[0], q[0], c)
 417         // amd64:"SBBQ",-"NEGL",-"NEGQ"
 418         r[1], c = bits.Sub(p[1], q[1], c)
 419         r[2], c = bits.Sub(p[2], q[2], c)
 420 }
 421
 422 func Sub64(x, y, ci uint64) (r, co uint64) {
 423         // amd64:"NEGL","SBBQ","NEGQ"
 424         return bits.Sub64(x, y, ci)
 425 }
 426
 427 func Sub64C(x, ci uint64) (r, co uint64) {
 428         // amd64:"NEGL","SBBQ","NEGQ"
 429         return bits.Sub64(x, 7, ci)
 430 }
 431
 432 func Sub64Z(x, y uint64) (r, co uint64) {
 433         // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
 434         return bits.Sub64(x, y, 0)
 435 }
 436
 437 func Sub64R(x, y, ci uint64) uint64 {
 438         // amd64:"NEGL","SBBQ",-"NEGQ"
 439         r, _ := bits.Sub64(x, y, ci)
 440         return r
 441 }
 442 func Sub64M(p, q, r *[3]uint64) {
 443         var c uint64
 444         r[0], c = bits.Sub64(p[0], q[0], c)
 445         // amd64:"SBBQ",-"NEGL",-"NEGQ"
 446         r[1], c = bits.Sub64(p[1], q[1], c)
 447         r[2], c = bits.Sub64(p[2], q[2], c)
 448 }
 449
 450 // --------------- //
 451 //    bits.Mul*    //
 452 // --------------- //
 453
 454 func Mul(x, y uint) (hi, lo uint) {
 455         // amd64:"MULQ"
 456         // arm64:"UMULH","MUL"
 457         // ppc64:"MULHDU","MULLD"
 458         // ppc64le:"MULHDU","MULLD"
 459         return bits.Mul(x, y)
 460 }
 461
 462 func Mul64(x, y uint64) (hi, lo uint64) {
 463         // amd64:"MULQ"
 464         // arm64:"UMULH","MUL"
 465         // ppc64:"MULHDU","MULLD"
 466         // ppc64le:"MULHDU","MULLD"
 467         return bits.Mul64(x, y)
 468 }
 469
 470 // --------------- //
 471 //    bits.Div*    //
 472 // --------------- //
 473
 474 func Div(hi, lo, x uint) (q, r uint) {
 475         // amd64:"DIVQ"
 476         return bits.Div(hi, lo, x)
 477 }
 478
 479 func Div32(hi, lo, x uint32) (q, r uint32) {
 480         // arm64:"ORR","UDIV","MSUB",-"UREM"
 481         return bits.Div32(hi, lo, x)
 482 }
 483
 484 func Div64(hi, lo, x uint64) (q, r uint64) {
 485         // amd64:"DIVQ"
 486         return bits.Div64(hi, lo, x)
 487 }