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