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.
11 // ----------------------- //
12 // bits.LeadingZeros //
13 // ----------------------- //
15 func LeadingZeros(n uint) int {
18 // arm:"CLZ" arm64:"CLZ"
21 return bits.LeadingZeros(n)
24 func LeadingZeros64(n uint64) int {
27 // arm:"CLZ" arm64:"CLZ"
30 return bits.LeadingZeros64(n)
33 func LeadingZeros32(n uint32) int {
34 // amd64:"BSRQ","LEAQ",-"CMOVQEQ"
36 // arm:"CLZ" arm64:"CLZW"
39 return bits.LeadingZeros32(n)
42 func LeadingZeros16(n uint16) int {
43 // amd64:"BSRL","LEAL",-"CMOVQEQ"
45 // arm:"CLZ" arm64:"CLZ"
48 return bits.LeadingZeros16(n)
51 func LeadingZeros8(n uint8) int {
52 // amd64:"BSRL","LEAL",-"CMOVQEQ"
54 // arm:"CLZ" arm64:"CLZ"
57 return bits.LeadingZeros8(n)
64 func Len(n uint) int {
67 // arm:"CLZ" arm64:"CLZ"
73 func Len64(n uint64) int {
76 // arm:"CLZ" arm64:"CLZ"
82 func Len32(n uint32) int {
83 // amd64:"BSRQ","LEAQ",-"CMOVQEQ"
85 // arm:"CLZ" arm64:"CLZ"
91 func Len16(n uint16) int {
92 // amd64:"BSRL","LEAL",-"CMOVQEQ"
94 // arm:"CLZ" arm64:"CLZ"
100 func Len8(n uint8) int {
101 // amd64:"BSRL","LEAL",-"CMOVQEQ"
103 // arm:"CLZ" arm64:"CLZ"
109 // -------------------- //
111 // -------------------- //
113 func OnesCount(n uint) int {
114 // amd64:"POPCNTQ",".*x86HasPOPCNT"
115 // arm64:"VCNT","VUADDLV"
120 return bits.OnesCount(n)
123 func OnesCount64(n uint64) int {
124 // amd64:"POPCNTQ",".*x86HasPOPCNT"
125 // arm64:"VCNT","VUADDLV"
130 return bits.OnesCount64(n)
133 func OnesCount32(n uint32) int {
134 // amd64:"POPCNTL",".*x86HasPOPCNT"
135 // arm64:"VCNT","VUADDLV"
140 return bits.OnesCount32(n)
143 func OnesCount16(n uint16) int {
144 // amd64:"POPCNTL",".*x86HasPOPCNT"
145 // arm64:"VCNT","VUADDLV"
150 return bits.OnesCount16(n)
153 func OnesCount8(n uint8) int {
158 return bits.OnesCount8(n)
161 // ----------------------- //
162 // bits.ReverseBytes //
163 // ----------------------- //
165 func ReverseBytes(n uint) uint {
169 return bits.ReverseBytes(n)
172 func ReverseBytes64(n uint64) uint64 {
176 return bits.ReverseBytes64(n)
179 func ReverseBytes32(n uint32) uint32 {
183 return bits.ReverseBytes32(n)
186 func ReverseBytes16(n uint16) uint16 {
188 // arm64:"REV16W",-"UBFX",-"ORR"
189 // arm/5:"SLL","SRL","ORR"
192 return bits.ReverseBytes16(n)
195 // --------------------- //
196 // bits.RotateLeft //
197 // --------------------- //
199 func RotateLeft64(n uint64) uint64 {
206 return bits.RotateLeft64(n, 37)
209 func RotateLeft32(n uint32) uint32 {
210 // amd64:"ROLL" 386:"ROLL"
215 return bits.RotateLeft32(n, 9)
218 func RotateLeft16(n uint16) uint16 {
219 // amd64:"ROLW" 386:"ROLW"
220 return bits.RotateLeft16(n, 5)
223 func RotateLeft8(n uint8) uint8 {
224 // amd64:"ROLB" 386:"ROLB"
225 return bits.RotateLeft8(n, 5)
228 func RotateLeftVariable(n uint, m int) uint {
234 return bits.RotateLeft(n, m)
237 func RotateLeftVariable64(n uint64, m int) uint64 {
243 return bits.RotateLeft64(n, m)
246 func RotateLeftVariable32(n uint32, m int) uint32 {
252 return bits.RotateLeft32(n, m)
255 // ------------------------ //
256 // bits.TrailingZeros //
257 // ------------------------ //
259 func TrailingZeros(n uint) int {
260 // amd64:"BSFQ","MOVL\t\\$64","CMOVQEQ"
262 // arm64:"RBIT","CLZ"
264 // ppc64:"ANDN","POPCNTD"
265 // ppc64le:"ANDN","POPCNTD"
267 return bits.TrailingZeros(n)
270 func TrailingZeros64(n uint64) int {
271 // amd64:"BSFQ","MOVL\t\\$64","CMOVQEQ"
272 // arm64:"RBIT","CLZ"
274 // ppc64:"ANDN","POPCNTD"
275 // ppc64le:"ANDN","POPCNTD"
277 return bits.TrailingZeros64(n)
280 func TrailingZeros32(n uint32) int {
281 // amd64:"BTSQ\\t\\$32","BSFQ"
283 // arm64:"RBITW","CLZW"
284 // s390x:"FLOGR","MOVWZ"
285 // ppc64:"ANDN","POPCNTW"
286 // ppc64le:"ANDN","POPCNTW"
288 return bits.TrailingZeros32(n)
291 func TrailingZeros16(n uint16) int {
292 // amd64:"BSFL","BTSL\\t\\$16"
293 // arm:"ORR\t\\$65536","CLZ",-"MOVHU\tR"
294 // arm64:"ORR\t\\$65536","RBITW","CLZW",-"MOVHU\tR",-"RBIT\t",-"CLZ\t"
295 // s390x:"FLOGR","OR\t\\$65536"
296 // ppc64:"POPCNTD","OR\\t\\$65536"
297 // ppc64le:"POPCNTD","OR\\t\\$65536"
299 return bits.TrailingZeros16(n)
302 func TrailingZeros8(n uint8) int {
303 // amd64:"BSFL","BTSL\\t\\$8"
304 // arm:"ORR\t\\$256","CLZ",-"MOVBU\tR"
305 // arm64:"ORR\t\\$256","RBITW","CLZW",-"MOVBU\tR",-"RBIT\t",-"CLZ\t"
306 // s390x:"FLOGR","OR\t\\$256"
308 return bits.TrailingZeros8(n)
311 // IterateBitsNN checks special handling of TrailingZerosNN when the input is known to be non-zero.
313 func IterateBits(n uint) int {
316 // amd64:"BSFQ",-"CMOVEQ"
317 i += bits.TrailingZeros(n)
323 func IterateBits64(n uint64) int {
326 // amd64:"BSFQ",-"CMOVEQ"
327 i += bits.TrailingZeros64(n)
333 func IterateBits32(n uint32) int {
336 // amd64:"BSFL",-"BTSQ"
337 i += bits.TrailingZeros32(n)
343 func IterateBits16(n uint16) int {
346 // amd64:"BSFL",-"BTSL"
347 // arm64:"RBITW","CLZW",-"ORR"
348 i += bits.TrailingZeros16(n)
354 func IterateBits8(n uint8) int {
357 // amd64:"BSFL",-"BTSL"
358 // arm64:"RBITW","CLZW",-"ORR"
359 i += bits.TrailingZeros8(n)
365 // --------------- //
367 // --------------- //
369 func Add(x, y, ci uint) (r, co uint) {
370 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
371 return bits.Add(x, y, ci)
374 func AddC(x, ci uint) (r, co uint) {
375 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
376 return bits.Add(x, 7, ci)
379 func AddZ(x, y uint) (r, co uint) {
380 // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
381 return bits.Add(x, y, 0)
384 func AddR(x, y, ci uint) uint {
385 // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
386 r, _ := bits.Add(x, y, ci)
389 func AddM(p, q, r *[3]uint) {
391 r[0], c = bits.Add(p[0], q[0], c)
392 // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
393 r[1], c = bits.Add(p[1], q[1], c)
394 r[2], c = bits.Add(p[2], q[2], c)
397 func Add64(x, y, ci uint64) (r, co uint64) {
398 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
399 return bits.Add64(x, y, ci)
402 func Add64C(x, ci uint64) (r, co uint64) {
403 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
404 return bits.Add64(x, 7, ci)
407 func Add64Z(x, y uint64) (r, co uint64) {
408 // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
409 return bits.Add64(x, y, 0)
412 func Add64R(x, y, ci uint64) uint64 {
413 // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
414 r, _ := bits.Add64(x, y, ci)
417 func Add64M(p, q, r *[3]uint64) {
419 r[0], c = bits.Add64(p[0], q[0], c)
420 // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
421 r[1], c = bits.Add64(p[1], q[1], c)
422 r[2], c = bits.Add64(p[2], q[2], c)
425 // --------------- //
427 // --------------- //
429 func Sub(x, y, ci uint) (r, co uint) {
430 // amd64:"NEGL","SBBQ","NEGQ"
431 return bits.Sub(x, y, ci)
434 func SubC(x, ci uint) (r, co uint) {
435 // amd64:"NEGL","SBBQ","NEGQ"
436 return bits.Sub(x, 7, ci)
439 func SubZ(x, y uint) (r, co uint) {
440 // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
441 return bits.Sub(x, y, 0)
444 func SubR(x, y, ci uint) uint {
445 // amd64:"NEGL","SBBQ",-"NEGQ"
446 r, _ := bits.Sub(x, y, ci)
449 func SubM(p, q, r *[3]uint) {
451 r[0], c = bits.Sub(p[0], q[0], c)
452 // amd64:"SBBQ",-"NEGL",-"NEGQ"
453 r[1], c = bits.Sub(p[1], q[1], c)
454 r[2], c = bits.Sub(p[2], q[2], c)
457 func Sub64(x, y, ci uint64) (r, co uint64) {
458 // amd64:"NEGL","SBBQ","NEGQ"
459 return bits.Sub64(x, y, ci)
462 func Sub64C(x, ci uint64) (r, co uint64) {
463 // amd64:"NEGL","SBBQ","NEGQ"
464 return bits.Sub64(x, 7, ci)
467 func Sub64Z(x, y uint64) (r, co uint64) {
468 // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
469 return bits.Sub64(x, y, 0)
472 func Sub64R(x, y, ci uint64) uint64 {
473 // amd64:"NEGL","SBBQ",-"NEGQ"
474 r, _ := bits.Sub64(x, y, ci)
477 func Sub64M(p, q, r *[3]uint64) {
479 r[0], c = bits.Sub64(p[0], q[0], c)
480 // amd64:"SBBQ",-"NEGL",-"NEGQ"
481 r[1], c = bits.Sub64(p[1], q[1], c)
482 r[2], c = bits.Sub64(p[2], q[2], c)
485 // --------------- //
487 // --------------- //
489 func Mul(x, y uint) (hi, lo uint) {
491 // arm64:"UMULH","MUL"
492 // ppc64:"MULHDU","MULLD"
493 // ppc64le:"MULHDU","MULLD"
494 return bits.Mul(x, y)
497 func Mul64(x, y uint64) (hi, lo uint64) {
499 // arm64:"UMULH","MUL"
500 // ppc64:"MULHDU","MULLD"
501 // ppc64le:"MULHDU","MULLD"
502 return bits.Mul64(x, y)
505 // --------------- //
507 // --------------- //
509 func Div(hi, lo, x uint) (q, r uint) {
511 return bits.Div(hi, lo, x)
514 func Div32(hi, lo, x uint32) (q, r uint32) {
515 // arm64:"ORR","UDIV","MSUB",-"UREM"
516 return bits.Div32(hi, lo, x)
519 func Div64(hi, lo, x uint64) (q, r uint64) {
521 return bits.Div64(hi, lo, x)